EasyTrip/BusClass.cpp at main · F4ntasticFour/EasyTrip · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include "BusClass.h"

#include "CompanyClass.h"

BusClass::BusClass(int BusID, const std::string& busType, TimeClass TimeBetweenStations, int busCapacity,
                   TimeClass checkUpTime, int TripsBeforeCheckUp, int BusCurrentStation)


    : BusID(BusID), BusType(busType), TimeBetweenStations(TimeBetweenStations), BusCapacity(busCapacity),
      CheckUpTime(checkUpTime), BusCurrentStation(0), TripsBeforeCheckUp(TripsBeforeCheckUp) {
}

// Getters
std::string BusClass::getBusType() const {
    return BusType;
}

int BusClass::getBusCapacity() const {
    return BusCapacity;
}

int BusClass::getJourneyCompleted() const {
    return JourneyCompleted;
}

int BusClass::getBusCurrentStation() {
    return BusCurrentStation;
}

int BusClass::getBusID() const {
    return BusID;
}

TimeClass BusClass::getCheckUpTime() const {
    return CheckUpTime;
}

bool BusClass::getIsMoved() {
    return isMoved;
}

std::string BusClass::getBusDirection() {
    return busDirection;
}

// Setters
void BusClass::setBusType(const std::string& busType) {
    BusType = busType;
}

void BusClass::setBusCapacity(int busCapacity) {
    BusCapacity = busCapacity;
}

void BusClass::setJourneyCompleted(int journeyCompleted) {
    JourneyCompleted = journeyCompleted;
}

void BusClass::setCheckUpTime(TimeClass checkUpTime) {
    CheckUpTime = checkUpTime;
}

void BusClass::setBusCurrentStation(int BusCurrentStation) {
    BusClass::BusCurrentStation = BusCurrentStation;
}

bool BusClass::setIsMoved(bool Moved) {
    isMoved = Moved;
}

void BusClass::setBusDirection(std::string Direction) {
    busDirection = Direction;
}

void BusClass::tickJourneyCompleted() {
    JourneyCompleted++;
}

void BusClass::clearJourneyCompleted() {
    JourneyCompleted = 0;
}

void BusClass::performMaintenance() {
    JourneyCompleted = 0;

}

bool BusClass::onBoardPassenger(PassengerClass* Passenger) {
    if (getOnBoardPassengerCount() < BusCapacity) {
        if (BusType == "Wbus" && Passenger->getPassengerType() == "WP") {
            PassengersOnBoard.enqueue(Passenger);
            return true;
        }
        if (BusType == "Mbus" && (Passenger->getPassengerType() == "SP" || Passenger->getPassengerType() == "NP")) {
            PassengersOnBoard.enqueue(Passenger);
            return true;
        }
        return false;
    }
    return false;
}

void BusClass::offBoardPassenger(CompanyClass* Company, TimeClass& time) {
    Queue<PassengerClass *> tempQueue;
    while (!PassengersOnBoard.isEmpty()) {
        PassengerClass* currentPassenger = PassengersOnBoard.frontElement();
        PassengersOnBoard.dequeue();
        if (currentPassenger->getEndStation() == BusCurrentStation) {
            currentPassenger->setLeaveTime(time);
            Company->ADDFinishedpassengers(currentPassenger);
            std::cerr<<"Passenger "<< currentPassenger->getPassengerID()<<" got off at station "<<BusCurrentStation<<std::endl;
        } else {
            tempQueue.enqueue(currentPassenger);
        }
    }
    while (!tempQueue.isEmpty()) {
        PassengerClass* Passenger = tempQueue.frontElement();
        PassengersOnBoard.enqueue(Passenger);
        tempQueue.dequeue();
    }
}

int BusClass::getOnBoardPassengerCount() {
    return PassengersOnBoard.getLength();
}

bool BusClass::offBoardAllPassenger(CompanyClass* Company) {
    while (getOnBoardPassengerCount() > 0) {
        Company->addFinshedPassengers(PassengersOnBoard.frontElement(), this);
        PassengersOnBoard.dequeue();
    }
    return true;
}