Skip to content
Snippets Groups Projects
Select Git revision
  • ad0afee6faa7479425b5cd9f03188aa10fafb849
  • main default protected
2 results

matrices.py

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    rute.cpp 18.69 KiB
    #include "rute.h"
    
    using namespace std;
    
    extern Stoppesteder* gStoppesteder;
    
    Rute::Rute() {
    }
    
    Rute::~Rute() {
    }
    Stopp* Rute::ny(const int& eksisterende, int pos) {
        string stoppPlass = "";
        Stoppested *stoppested, *forrigeStoppested;
        Stopp *stopp, *forrigeStopp;
        stoppested = nullptr;
        stopp = nullptr;
        bool forsteStopp = true;
    
        do {
            forrigeStoppested = stoppested;
            forrigeStopp = stopp;
            if (eksisterende != -1) {
                forrigeStoppested = gStoppesteder->hentEksisterende(eksisterende);
                forrigeStopp = new Stopp;
                forrigeStopp->indexStoppested = eksisterende;
            }
            stopp = new Stopp;
            stoppested = nullptr;
            if (alleStoppestedenePaaRuten.size() > 0) forsteStopp = false;
            cout << "\nSkriv inn navn eller nummer på stoppeplass du ønsker "
                 << "å legge til (blankt for avbryt):";
            getline(cin, stoppPlass);
    
            // Strengen ikke er tom
            if (!stoppPlass.empty()) {
                stoppPlass = hjelp.rensStreng(stoppPlass);
                if (!hjelp.erBokstav(stoppPlass)) {
                    // Hvis tall
                    stoppested = gStoppesteder->hentEksisterende(stoi(stoppPlass) - 1);
                } else
                    // Else bokstav(r)
                    stoppested = gStoppesteder->hentEksisterende(stoppPlass);
    
                // Hvis stoppestedet ikke eksisterer fra før og input er bokstaver
                if (stoppested == nullptr && hjelp.erBokstav(stoppPlass)) {
                    cout << "\nError: Stoppested eksisterer ikke!" << '\n'
                         << "Oppretter nytt stoppsted basert på forrige gitte parameter."
                         << '\n';
                    if (forsteStopp)
                        gStoppesteder->ny(stoppPlass, false);
                    else
                        gStoppesteder->ny(stoppPlass, true);
                    stoppested = gStoppesteder->hentEksisterende(stoppPlass);
                }
                stopp->indexStoppested = gStoppesteder->hentIndex(stoppested);
    
                // Er ikke første stopp og har ikke nabostopp
                if (!forsteStopp && stoppested->hentTidNaboStopp() < 0) {
                    stopp->minutterFraForrigeStoppested = lesTid();
                } else if (forsteStopp)
                    stopp->minutterFraForrigeStoppested = 0;
                else {
                    stopp->minutterFraForrigeStoppested = -1;  // stoppested->hentTidNaboStopp();
                }
                if (!sjekkOmStoppEksisterer(stopp)) {
                    oppdaterStoppestedVectorer(stoppested,
                                               forrigeStoppested,
                                               stopp,
                                               forrigeStopp);
                    if (eksisterende != -1 && pos == alleStoppestedenePaaRuten.size()) {
                        alleStoppestedenePaaRuten.push_back(stopp);
                    } else if (eksisterende != -1) {
                        auto it = alleStoppestedenePaaRuten.begin();
                        advance(it, pos);
    
                        Stopp* tmpstopp = *it;
                        int tmpTid = tmpstopp->minutterFraForrigeStoppested;
                        tmpstopp->minutterFraForrigeStoppested = stopp->minutterFraForrigeStoppested;
                        stopp->minutterFraForrigeStoppested = tmpTid;
                        // slettStoppested(pos, pos);
    
                        alleStoppestedenePaaRuten.insert(it, stopp);
    
                        pos++;
    
                    } else
                        alleStoppestedenePaaRuten.push_back(stopp);
                    cout << "\nStopp lagt til!" << '\n';
                    // return stopp;
                } else
                    cout << "\nError: Stopp er allerede lagt til!" << '\n';
            }
        } while (!stoppPlass.empty());
    
        // Hvis ikke nok stopp er lagt inn på ruten
        if (alleStoppestedenePaaRuten.size() <= 1 && eksisterende != -1) {
            cout << "\nIkke nok stopp lagt inn! Avbryter" << '\n';
            return nullptr;
        }
        return stopp;
    }
    
    void Rute::ryddOppMinne() {
        for (const auto& val : alleStoppestedenePaaRuten) {
            delete val;
        }
        alleStoppestedenePaaRuten.clear();
    }
    bool Rute::sjekkOmStoppEksisterer(Stopp* stopp) {
        for (const auto& val : alleStoppestedenePaaRuten) {
            if (val->indexStoppested == stopp->indexStoppested) return true;
        }
        return false;
    }
    
    void Rute::skrivData() {
        skrivDataForlengs();
        skrivDataBaklengs();
    }
    
    void Rute::skrivDataForlengs() {
        Stoppested* stopp;
        int totalTid, storrelseListe;
        totalTid = 0;
        storrelseListe = alleStoppestedenePaaRuten.size();
        cout << "\n\n..::Stoppested navn\tTid mellom stopp"
             << "\tTotal tid fra rutestart::..";
        for (const auto& val : alleStoppestedenePaaRuten) {
            if (val->minutterFraForrigeStoppested != 0)
                totalTid += val->minutterFraForrigeStoppested;
            stopp = gStoppesteder->hentEksisterende(val->indexStoppested);
            if (stopp != nullptr) {
                cout << "\n\t"
                     << stopp->hentNavn()
                     << "\t" << val->minutterFraForrigeStoppested
                     << "\t" << totalTid;
            }
        }
    }
    
    void Rute::skrivDataBaklengs() {
        Stoppested* stoppested;
        Stopp *stopp, *forrigeStopp;
        int totalTid, storrelseListe;
        bool forste = true;
    
        totalTid = 0;
        cout << "\n\n..::Stoppested navn\tTid mellom stopp"
             << "\tTotal tid fra rutestart::..";
    
        for (auto it = alleStoppestedenePaaRuten.rbegin();
             it != alleStoppestedenePaaRuten.rend(); it++) {
            stopp = *it;
            stoppested = gStoppesteder->hentEksisterende(stopp->indexStoppested);
            if (!forste) {
                totalTid += forrigeStopp->minutterFraForrigeStoppested;
                cout << "\n\t"
                     << stoppested->hentNavn()
                     << "\t" << forrigeStopp->minutterFraForrigeStoppested
                     << "\t" << totalTid;
            } else {
                cout << "\n\t"
                     << stoppested->hentNavn()
                     << "\t" << 0
                     << "\t" << 0;
                forste = false;
            }
            forrigeStopp = *it;
        }
    }
    
    void Rute::endre() {
        int valg, antall;
        cout << "\n\n1 - Slett stoppested\n2 - Smett inn stoppested\n0 - Avbryt" << '\n';
        valg = lesInt("Kommando", 0, 2);
        antall = alleStoppestedenePaaRuten.size();
        if (valg > 0) {
            int start, slutt;
            start = slutt = 0;
            start = lesInt("Hvilke stoppested utgjør start punktet?",
                           1, antall);
            // if (start + 1 >= alleStoppestedenePaaRuten.size())
            if (valg == 1 && antall > 2 && start < antall) {
                slutt = lesInt("Hvilket stoppested utgjør slutt ytterpunkt?",
                               start + 2, antall);
                slettStoppested(start, slutt);
            } else if (valg == 2)
                slutt = lesInt("Hvilket stoppested utgjør slutt ytterpunkt?",
                               start, antall);
            else
                cout << "\nError i sletting: ugyldig input!" << '\n';
    
            if (valg == 2 && slutt - 1 == start || valg == 2 && slutt == start)
                smettInnStoppested(start, slutt);
    
            /*else if (valg == 1 && start == slutt - 1 || slutt == 0)
                cout << "\nError i sletting: ugyldig input!" << '\n';*/
            else if (valg == 2)
                cout << "\nError: For smett inn så må slutt være rett etter start "
                     << "for at innsmettingen skal være entydig!\n";  //" << '\n'
        }
    }
    
    void Rute::slettStoppested(const int& start, const int& slutt) {
        Stopp* stopp;
        cout << "\nlist size: " << alleStoppestedenePaaRuten.size() << "\n\n";
        auto it = alleStoppestedenePaaRuten.begin();
        advance(it, start);
        for (int i = start; i < slutt - 1; i++) {
            stopp = *it;
            delete stopp;
            it = alleStoppestedenePaaRuten.erase(it);
        }
        skrivData();
    }
    
    void Rute::smettInnStoppested(const int& start, const int& slutt) {
        Stopp* stopp;
        list<Stopp*>::iterator it = alleStoppestedenePaaRuten.begin();
        advance(it, start - 1);
        stopp = *it;
        if (slutt == start && start < alleStoppestedenePaaRuten.size())
            ny(stopp->indexStoppested, start - 1);
        else
            ny(stopp->indexStoppested, start);
    }
    
    void Rute::leggTilStoppestedIRute(Stopp* stopp) {
        if (stopp != nullptr)
            alleStoppestedenePaaRuten.push_back(stopp);
    }
    
    void Rute::skrivType() {
    }
    
    void Rute::oppdaterStoppestedVectorer(Stoppested* stoppested,
                                          Stoppested* forrigeStoppested,
                                          Stopp* stopp,
                                          Stopp* forrigeStopp) {
        int tmpTid2, tmpTid;
        tmpTid2 = tmpTid = -1;
        int antIVec = stoppested->hentAntallStoppestedVector();
        Stoppested* tmpstd = stoppested;
        // gStoppesteder->hentEksisterende(stoppested->hentNaboStoppIndex(true));
        //  Stoppested* tmpstd2 = gStoppesteder->hentEksisterende(stoppested->hentNaboStoppIndex(true));
        if (stoppested != nullptr) {
            tmpTid = stoppested->hentTidNaboStopp();
            // tmpTid2 = tmpstd2->hentTidNaboStopp();
        }
    
        if (forrigeStoppested != nullptr) {
            if (stopp->minutterFraForrigeStoppested == -1) {
                /*     for (const auto& val : gStoppesteder->alleStoppesteder) {
                         if (val->hentNaboStoppIndex(true) == stopp->indexStoppested) {
                             forrigeStoppested->leggTilNaboBakerst(stopp->indexStoppested,
                                                                   val->hentTidNaboStopp());
                             cout << val->hentTidNaboStopp() << "\n\n";
                             //break;
                         }
                     }*/
                tmpTid2 = stoppested->hentTidForsteNabo();
                if (tmpTid2 == -1) tmpTid2 = stoppested->hentTidNaboStopp();
                // Legger nåværende stopp til i forrige stoppested
                forrigeStoppested->leggTilNaboBakerst(stopp->indexStoppested,
                                                      tmpTid2);
                cout << "\n\n||" << tmpTid2 << " : "
                     << stopp->indexStoppested << "\n\n";
    
            } else
                forrigeStoppested->leggTilNaboBakerst(stopp->indexStoppested,
                                                      stopp->minutterFraForrigeStoppested);
    
            if (stoppested->hentIndex() != forrigeStopp->indexStoppested) {
                if (stopp->minutterFraForrigeStoppested == -1) {
                    // Legger til nåværende stopp til stoppested
                    stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                                  tmpTid2);
                    cout << "\n\n--" << tmpTid2
                         << " : " << forrigeStopp->indexStoppested << "\n\n";
                } else
                    stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                                  stopp->minutterFraForrigeStoppested);
    
                /*if (forrigeStopp->minutterFraForrigeStoppested > 0)
                    stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                                  forrigeStopp->minutterFraForrigeStoppested);
                else
                    stoppested->leggTilNaboFremst(forrigeStopp->indexStoppested,
                                                  stopp->minutterFraForrigeStoppested);*/
            }
        } else if (antIVec < 1) {
            stoppested->leggTilNaboStopp(-1, -1);
        }
        // Gir stopp nabo-tid slik at rute beskrivelse fungerer korrekt
        if (stopp->minutterFraForrigeStoppested == -1)
            stopp->minutterFraForrigeStoppested = stoppested->hentTidNaboStopp();
    
        // stopp->minutterFraForrigeStoppested = tmpTid;
    }
    
    int Rute::lesTid() {
        return lesInt("Tid mellom forrige stopp i minutter",
                      MIN_MINUTTER,
                      MAX_MINUTTER);
    }
    
    void Rute::tabell() {
        Retning retning = Annen;
        Stoppested* stoppested;
        string stopp, stopp2, navn;
        char valg = '\0';
        bool ikkeFullt, igjen;
        ikkeFullt = igjen = true;
        vector<vector<int>> valgtTid;
        int avgangsTid, fraKlTime, fraKlMin, tilKlTime, tilKlMin,
            tmpTime, tmpMin, forrigeTmpMin, totTid, utregning;
    
        tmpTime = tmpMin = forrigeTmpMin = totTid = utregning = fraKlTime = 0;
        tilKlMin = MIN_MINUTTER;
        tilKlTime = MIN_TIMER;
        stopp = gStoppesteder->hentEksisterende(
                                 alleStoppestedenePaaRuten.front()->indexStoppested)
                    ->hentNavn();
        stopp2 = gStoppesteder->hentEksisterende(
                                  alleStoppestedenePaaRuten.back()->indexStoppested)
                     ->hentNavn();
        cout << "\nFram: Retningen: "
             << stopp
             << " - "
             << stopp2
             << "\nTilbake: Retningen: "
             << stopp2
             << " - "
             << stopp
             << '\n'
             << "\nVelg retning F = Fram, T = Tilbake"
             << '\n';
    
        while (valg != 'F' && valg != 'T') {
            valg = lesChar("Kommando: ");
            if (valg == 'F')
                retning = Fram;
            else if (valg == 'T')
                retning = Tilbake;
    
            switch (retning) {
                case Fram:
                    skrivDataForlengs();
                    break;
                case Tilbake:
                    skrivDataBaklengs();
                    break;
                default:
                    cout << "\nUgyldig valg!" << '\n';
                    break;
            }
        }
        cout << "\n\nSkriv inn navnet på stoppet: ";
        getline(cin, navn);
        navn = hjelp.rensStreng(navn);
        stoppested = gStoppesteder->hentEksisterende(navn);
        if (stoppested != nullptr) {
            cout << "\nTime= 0 og Minutt= 0 for å AVSLUTTE innlesning" << '\n';
            do {
                igjen = true;
                do {
                    cout << "\nFra kl. (";
                    hjelp.skrivKlokkeslett(tilKlTime, tilKlMin);
                    cout << " - ";
                    hjelp.skrivKlokkeslett(MAX_TIMER, MAX_MINUTTER);
                    cout << "): "
                         << "\nTime: ";
                    fraKlTime = hjelp.lesTall();
                    cout << "\nMinutt: ";
                    fraKlMin = hjelp.lesTall();
                    if (fraKlTime < MAX_TIMER &&
                        fraKlTime > tilKlTime &&
                        fraKlMin < MAX_MINUTTER &&
                        fraKlMin >= 0)
                        igjen = false;
                    if (fraKlTime <= 0 && fraKlMin <= 0)
                        igjen = false;
                } while (igjen);
    
                // Hvis ikke avslutte
                if (fraKlTime > 0 || fraKlMin > 0) {
                    avgangsTid = lesInt("Tid mellom avganger", MIN_AVGANGS_TID, MAX_AVGANGS_TID);
    
                    tmpTime = fraKlTime + (avgangsTid / 60);
                    tmpMin = fraKlMin + (avgangsTid % 60);
                    if (tmpMin > MAX_MINUTTER) {
                        tmpTime++;
                        tmpMin = tmpMin % 60;
                    }
    
                    // Hvis tid gitt går over max verdi i.e. 24t
                    if (tmpTime > MAX_TIMER)
                        ikkeFullt = false;
    
                    do {
                        cout << "\nTil kl. (";
                        hjelp.skrivKlokkeslett(tmpTime, tmpMin);
                        cout << " - ";
                        hjelp.skrivKlokkeslett(MAX_TIMER, MAX_MINUTTER);
                        cout << "): "
                             << "\nTime: ";
                        tilKlTime = hjelp.lesTall();
                        cout << "\nMinutt: ";
                        tilKlMin = hjelp.lesTall();
                    } while (tilKlTime > MAX_TIMER ||
                             tilKlTime < tmpTime ||
                             tilKlMin > MAX_MINUTTER || tilKlMin < 0);
    
                    /*if (fraKlTime == 0 && fraKlMin == 0 ||
                        tilKlTime == 0 && tilKlMin == 0)
                        cout << "\nAvbryter" << '\n';*/
    
                    // Legger til tider i vector
                    if (ikkeFullt) {
                        valgtTid.push_back({fraKlTime, tmpTime, tmpMin, avgangsTid,
                                            tilKlTime, tilKlMin});
                    }
                } else {
                    fraKlTime = fraKlMin = tilKlTime = tilKlMin = 0;
                    //cout << "\nAvbryter" << '\n';
                }
    
            } while (fraKlTime > 0 || fraKlMin > 0 || tilKlTime > 0 || tilKlMin > 0);  // fraKlTime != 0 || fraKlMin != 0 && tilKlTime != 0 || tilKlMin != 0 && ikkeFullt);
    
            if (retning == Fram)
                totTid = hentTotalTidForan(gStoppesteder->hentIndex(stoppested));
            else
                totTid = hentTotalTidTilbake(gStoppesteder->hentIndex(stoppested));
    
            // Har tid har blitt lagt til i vector
            if (valgtTid.size() > 0) {
                cout << "\n\t..::Rutetabell for stoppestedet: " << navn
                     << "::.."
                     << "\n\n";
                // Klokkeslett
                for (int i = valgtTid.front()[0];
                     i <= valgtTid.back()[4]; i++) {
                    if (i <= 9)
                        cout << "\t\t0" << i;
                    else
                        cout << "\t\t" << i;
                    cout << ":";
                    // Tabell for stopp på 'i' klokkeslett
                    for (const auto& val : valgtTid) {
                        if (i >= val[0] && i <= val[4]) {
                            // cout << "inne i if!\n\n";
                            // int iEnTime = (60 / (totTid + val[2]));
                            int tall = totTid + val[2];
                            igjen = true;
                            while (igjen) {
                                if (tall < MAX_MINUTTER) {
                                    cout << "\t" << tall;
                                    tall += tall;
                                } else
                                    igjen = false;
                            }
                            // else cout << "\t" << totTid + val[2];
    
                            /* utregning = (totTid + val[2]) / 60;
                             if (utregning < MAX_MINUTTER)
    
                                 else if (i == val[4] - 1) {
                                     cout << "\t" << totTid + val[1];
                                 }*/
                        }
                    }
                    cout << '\n';
                }
            }
        } else
            cout << "\nError: Fant ikke noe stoppested med det navnet!" << '\n';
    }
    
    int Rute::hentTotalTidForan(const int& pos) {
        int totalTid;
        totalTid = 0;
        for (const auto& val : alleStoppestedenePaaRuten) {
            if (val->minutterFraForrigeStoppested != 0)
                totalTid += val->minutterFraForrigeStoppested;
            if (val->indexStoppested == pos)
                return totalTid;
        }
        return -1;
    }
    
    int Rute::hentTotalTidTilbake(const int& pos) {
        Stopp *stopp, *forrigeStopp;
        int totalTid;
        bool forste = true;
        totalTid = 0;
    
        for (auto it = alleStoppestedenePaaRuten.rbegin();
             it != alleStoppestedenePaaRuten.rend(); it++) {
            stopp = *it;
            if (!forste) {
                totalTid += forrigeStopp->minutterFraForrigeStoppested;
                if (stopp->indexStoppested == pos) return totalTid;
            } else {
                forste = false;
            }
            forrigeStopp = *it;
        }
        return -1;
    }
    // int Ruter::finnTidTilNesteIRute()