Spur.cpp

gehe zur Dokumentation dieser Datei

#include "Fehler.h"
#include "Konstanten.h"
#include "Spur.h"
class Fahrzeug;

Spur::Spur( ){
        clear();
}


Spur::Spur( long int id, double laenge, int maximalGeschwindigkeit){
        clear();
        id_ = id;
        laenge_ = laenge;
        maximalGeschwindigkeit_ = maximalGeschwindigkeit;       
}


int Spur::gibAnzahlFahrzeuge( ){
        return anzahlFahrzeuge_;
}

int Spur::gibAnzahlAbgefahrenerFahrzeuge( int typ ){
        int anzahl;
        if( typ > 0 && typ < 5 ){
                anzahl = statistik_[typ-1];     
                statistik_[typ-1] = 0;
        }
        else if( typ == 0 ){
                anzahl = statistik_[0] + statistik_[1] + statistik_[2] + statistik_[3];
                statistik_[0] = 0;
                statistik_[1] = 0;
                statistik_[2] = 0;
                statistik_[3] = 0;
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDer Typ eines Fahrzeuges liegt ausserhalb der Grenzen.");
                throw(fehler);
        }

        return anzahl;
}

int Spur::gibEndzustand( ){
        return endzustand_;
}


void Spur::setzeEndzustand(int zustand){
        if( zustand >= 0 && zustand < 4 ){
                endzustand_ = zustand;
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDas Endeflag fuer eine Spur einspricht nicht den Vorgaben.");
                throw(fehler);
        }
}



void Spur::setzeNaechstesVerbindungselement(Spur *spur, int richtung, double wahrscheinlichkeit){
        if( richtung > 0 && richtung < 4 && wahrscheinlichkeit <= 1 && wahrscheinlichkeit >= 0 ){
                spur_[richtung-1] = spur;
                wahrscheinlichkeit_[richtung-1] = wahrscheinlichkeit;
                spur->setzeAbbiegerichtung( richtung );
                setzeGruen();
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDie Wahrscheinlichkeit fuer eine nicht existierende Richtung sollte gesetzt werden.");
                throw(fehler);
        }
}


double Spur::gibWahrscheinlichkeit(int richtung){
        if( richtung > 0 && richtung < 4 ){
                return wahrscheinlichkeit_[richtung-1];
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDie Wahrscheinlichkeit fuer eine nicht existierende Richtung wurde abgefragt.");
                throw(fehler);
        }
        return 0;
}


void Spur::anmelden(Fahrzeug *fahrzeug){
        if( anzahlFahrzeuge_ < 1000){
                fahrzeugListe_[anzahlFahrzeuge_] = fahrzeug;
                anzahlFahrzeuge_++;
        }
        else{
                Fehler  *fehler = new Fehler("Auf einer Spur befinden sich mehr als 1000 Fahrzeuge.");
                throw( fehler );
        }
}


void Spur::abmelden(Fahrzeug *fahrzeug){
        int position(0), i(0);

        // Eigentlich ist das Fahrzeug welches sich abmeldet immer das erste --> Ueberpruefen
        if( fahrzeugListe_[0] != 0 && fahrzeugListe_[0]->gibId() == fahrzeug->gibId() ){
                position = 0;
        }
        else{
                // Sonst das Fahrzeug in der Liste suchen und die Position merken
                for( position = 0; position < 1000; position++){
                        if( fahrzeugListe_[position] != 0 && fahrzeugListe_[position]->gibId() == fahrzeug->gibId() ){
                                break;
                        }
                }
                // Kommt das Programm hier an, dann gibt es das Fahrzeug nicht
                Fehler  *fehler = new Fehler("Aus einer Spur soll ein dort nicht befindliches Fahrzeug geloescht werden.");
                throw( fehler );
        }

        // Alle nach dem abzumeldenden Fahrzeug um eins nach vorn schieben
        for( i = position; i < 999; i++ ){
                fahrzeugListe_[i] = fahrzeugListe_[i+1];
        }
        fahrzeugListe_[999] = 0;

        anzahlFahrzeuge_--;

        // das Fahrzeug in die Statistiken aufnehmen
        statistik_[fahrzeug->gibTyp()-1]++;
}


double Spur::gibLaenge(){
        return laenge_;
}

Fahrzeug* Spur::gibVorgaenger(Fahrzeug *fahrzeug){
        int position(0);

        for( position = 0; position < anzahlFahrzeuge_; position++){
                if( fahrzeugListe_[position]->gibId() == fahrzeug->gibId() ){
                        if( position > 0 ){
                                return fahrzeugListe_[position-1];
                        }
                }
        }

        return 0;
}

Fahrzeug* Spur::gibLetztes(){
        if( anzahlFahrzeuge_ > 1 ){
                return fahrzeugListe_[anzahlFahrzeuge_-1];
        }
        else{
                return 0;
        }
}

long int Spur::gibId(){
        return id_;
}


Spur *Spur::gibNaechsteSpur(int richtung){
        if( richtung > 0 && richtung < 4 && spur_[richtung-1] != 0 ){
                return spur_[richtung-1];
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDie gewuenschte Spur existiert nicht.");
                throw(fehler);
        }
}


double Spur::gibMaximaleGeschwindigkeit(){
        return maximalGeschwindigkeit_;
}


void Spur::clear(){
        int i(0);
        for( i=0; i<1000; i++){
                fahrzeugListe_[i] = 0;
        }
        for( i = 0; i<4; i++ ){
                statistik_[i] = 0;
        }

        wahrscheinlichkeit_[0] = 0;
        wahrscheinlichkeit_[1] = 0;
        wahrscheinlichkeit_[2] = 0;
        spur_[0] = 0;
        spur_[1] = 0;
        spur_[2] = 0;
        nachfolger_[0] = 0;
        nachfolger_[1] = 0;
        nachfolger_[2] = 0;
        maximalGeschwindigkeit_ = 50;
        laenge_ = 300;
        endzustand_ = STOP;             // immer erst einmal auf eine Sackgasse setzen
        anzahlFahrzeuge_ = 0;
        abbiegerichtung_ = NICHTS;
        richtung_ = MITTE;
}


void Spur::setzeGruen(){
        setzeEndzustand(GRUEN);
}


void Spur::setzeGelb(){
        setzeEndzustand(GELB);
}


void Spur::setzeRot(){
        setzeEndzustand(ROT);
}


void Spur::setzeSackgasse(){
        setzeEndzustand(STOP);
}


bool Spur::istGruen(){
        if( gibEndzustand() == GRUEN )
                return 1;
        else
                return 0;
}


bool Spur::istGelb(){
        if( gibEndzustand() == GELB )
                return 1;
        else
                return 0;
}


bool Spur::istRot(){
        if( gibEndzustand() == ROT )
                return 1;
        else
                return 0;
}


bool Spur::istSackgasse(){
        if( gibEndzustand() == STOP )
                return 1;
        else
                return 0;
}

Koordinaten Spur::gibKoordinaten(){
        return koordinaten_;
}

void Spur::setzeKoordinaten( Koordinaten koordinaten ){
        koordinaten_ = koordinaten;
}

int Spur::gibAusrichtung(){
        return ausrichtung_;
}

void Spur::setzeAusrichtung( int ausrichtung ){
        ausrichtung_ = ausrichtung;
}

int Spur::gibRichtung(){
        return richtung_;
}

void Spur::setzeRichtung( int richtung ){
        richtung_ = richtung;
}

int Spur::gibAbbiegerichtung(){
        return abbiegerichtung_;
}

void Spur::setzeAbbiegerichtung( int abbiegerichtung ){
        if( abbiegerichtung > 0 && abbiegerichtung < 4){
                abbiegerichtung_ = abbiegerichtung;
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nEs soll eine Abbiegerichtung gesetzt werden, die nicht moeglich ist.");
                throw(fehler);
        }
        
}

long int Spur::gibNachfolgerId(int richtung){
        if( richtung > 0 && richtung < 4 && nachfolger_[richtung-1] != 0){
                return nachfolger_[richtung-1];
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDie Richtung eines Nachfolgers ist ausserhalb der zulaessigen Parameter.");
                throw(fehler);
        }
}

void Spur::setzeNaechstesVerbindungselement(int richtung, long int id, double wahrscheinlichkeit){
        if( richtung > 0 && richtung < 4 && wahrscheinlichkeit <= 1 && wahrscheinlichkeit >= 0 ){
                nachfolger_[richtung-1] = id;
                wahrscheinlichkeit_[richtung-1] = wahrscheinlichkeit;
        }
        else{
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDie Richtung eines Nachfolgers ist ausserhalb der zulaessigen Parameter.");
                throw(fehler);
        }
}

ostream &operator<< ( ostream &os, Spur *spur ){
        os << "----------Spur----------" << endl;
        os << "ID:                   " << spur->id_ << endl;
        os << "Endzustand:           " << spur->endzustand_ << "( 1 = gruen | 2 = gelb | 3 = rot | 0 = sackgasse )" << endl;
        os << "Laenge:               " << spur->laenge_ << " m" << endl;
        os << "max. Geschwindigkeit: " << spur->maximalGeschwindigkeit_ << " km/h" << endl;
        os << "p fuer links:         " << spur->wahrscheinlichkeit_[0] << endl;
        os << "p fuer gerade:        " << spur->wahrscheinlichkeit_[1] << endl;
        os << "p fuer rechts:        " << spur->wahrscheinlichkeit_[2] << endl;
        os << "Anzahl Fahrzeuge:     " << spur->anzahlFahrzeuge_ << endl;
        return os;
}

---