removed typo

Otherwise use timeSteps-member in Calculator.

library/include/mobilisis/calculate_price.h

@@ -111,7 +111,8 @@ int CALCULATE_LIBRARY_API get_zone_nr(int zone = -1);
 
 int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int currentTimeMinutes, int UpDown);
 
-QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg, qint64 startInMinutes = QDateTime::currentSecsSinceEpoch() / 60);
+QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg);
+int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration *cfg);
 
 CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(       // deprecated
                                             parking_tariff_t *tariff,

library/include/mobilisis/calculator_functions.h

@@ -13,9 +13,23 @@
 using namespace std;
 
 class Calculator {
-public:
+    mutable QList<int> m_timeSteps;
+
+protected:
     explicit Calculator() = default;
 
+public:
+    Calculator(Calculator const &other) = delete;
+    void operator=(Calculator const &) = delete;
+
+    static Calculator &GetInstance() {
+        static Calculator c;
+        return c;
+    }
+
+    void ResetTimeSteps() { m_timeSteps.clear(); }
+    QList<int> timeSteps() const { return m_timeSteps; }
+
 	/// <summary>
 	/// Gets duration in seconds from cost
 	/// </summary>
@@ -44,7 +58,7 @@ public:
     // helper function to find time steps for a tariff with PaymentMethod::Steps
     // (e.g. Schoenau/Koenigsee)
     //
-    QList<int> GetTimeSteps(Configuration *cfg, quint64 startInMinutes = QDateTime::currentSecsSinceEpoch() / 60) const;
+    QList<int> GetTimeSteps(Configuration *cfg) const;
     QList<int> GetSteps(Configuration *cfg) const { return GetTimeSteps(cfg); }
 
     // additional helper functions

library/src/calculate_price.cpp

@@ -10,10 +10,16 @@
 #include <QDebug>
 #include <QList>
 
-static Calculator calculator;
+QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg) {
+    return Calculator::GetInstance().GetTimeSteps(cfg);
+}
 
-QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg, qint64 startInMinutes) {
+int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration *cfg) {
-    return calculator.GetTimeSteps(cfg, startInMinutes);
+    // for each new sell-procedure, recomute the timesteps. implicitly, set
+    // the minimal parking time.
+    Calculator::GetInstance().ResetTimeSteps();
+    Calculator::GetInstance().GetTimeSteps(cfg);
+    return qRound(cfg->getPaymentOptions().pop_min_time);
 }
 
 int CALCULATE_LIBRARY_API get_zone_nr(int zone)
@@ -102,7 +108,9 @@ void CALCULATE_LIBRARY_API free_tariff(parking_tariff_t *tariff) {
 // UpDown 1 -> up; 0 -> down
 int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int currentTimeMinutes, int UpDown)
 {
-    qCritical() << "   compute_next_timestep()  currentTimeMinutes: " << currentTimeMinutes;
+    qCritical() << "   compute_next_timestep()     currentTimeMinutes: " << currentTimeMinutes;
+    qCritical() << "   compute_next_timestep() up/down (1=up, 0=down): " << UpDown;
+
     Configuration const *cfg = tariff;
 
     // compute payment method id (e.g. Linear=3, Steps=4)
@@ -129,7 +137,8 @@ int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int cu
     // without given YearPeriod, SpecialDays and SpecialDaysWorktime
     if (paymentMethodId == PaymentMethod::Steps)
     {
-        static const QList<int> stepList = calculator.GetTimeSteps(tariff);
+        const QList<int> stepList = Calculator::GetInstance().GetTimeSteps(tariff);
+        qCritical() << "   compute_next_timestep()     timeSteps:" << stepList;
 
         int currentStepIndex = stepList.indexOf(currentTimeMinutes);
 
@@ -230,7 +239,7 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
     start = start.toLocalTime().addSecs(start_parking_time * 60);
     QDateTime end(start);
     if (start.isValid()) {
-        double cost = calculator.GetCostFromDuration(
+        double cost = Calculator::GetInstance().GetCostFromDuration(
                     tariff,
                     tariff->getPaymentOptions().pop_payment_method_id,
                     start,
@@ -289,7 +298,7 @@ CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
     }
 
     if (start_parking_time.isValid()) {
-        double cost = calculator.GetCostFromDuration(
+        double cost = Calculator::GetInstance().GetCostFromDuration(
                         tariff,
                         tariff->getPaymentOptions().pop_payment_method_id,
                         start_parking_time,         // starting time
@@ -332,7 +341,7 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
         qCritical() << "      start (cs): " << cs;
         qCritical() << "           price: " << price;
 
-        duration = calculator.GetDurationFromCost(tariff,
+        duration = Calculator::GetInstance().GetDurationFromCost(tariff,
                                                   tariff->getPaymentOptions().pop_payment_method_id,
                                                   cs.toLocal8Bit().constData(),
                                                   price, false, true).c_str();
@@ -357,7 +366,7 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
     CalcState calcState;
     if (start_parking_time.isValid()) {
         QString cs = start_parking_time.toString(Qt::ISODate);
-        QString endTime = calculator.GetDurationFromCost(
+        QString endTime = Calculator::GetInstance().GetDurationFromCost(
                     tariff,
                     tariff->getPaymentOptions().pop_payment_method_id,
                     cs.toLocal8Bit().constData(),
@@ -385,7 +394,7 @@ CalcState CALCULATE_LIBRARY_API compute_duration_for_daily_ticket(parking_tariff
     CalcState calcState;
     if (start_parking_time.isValid()) {
 
-        ticketEndTime = calculator.GetDailyTicketDuration(tariff,
+        ticketEndTime = Calculator::GetInstance().GetDailyTicketDuration(tariff,
                                                             start_parking_time,
                                                             tariff->getPaymentOptions().pop_payment_method_id,
                                                             false);    // carry over

library/src/calculator_functions.cpp

@@ -695,90 +695,98 @@ Ticket Calculator::private_GetDurationFromCost(Configuration *cfg,
                cost, Ticket::s[VALID]);
 }
 
-QList<int> Calculator::GetTimeSteps(Configuration *cfg, quint64 startInMinutes) const {
+QList<int> Calculator::GetTimeSteps(Configuration *cfg) const {
-    static QList<int> timeSteps;
+    if (m_timeSteps.size() > 0) {
+        //qCritical() << __PRETTY_FUNCTION__ << "timeSteps:" << m_timeSteps;
+        return m_timeSteps;
+    }
 
-    if (timeSteps.size() == 0) {
+    QDateTime start = QDateTime::currentDateTime();
-        int const pop_id = cfg->getPaymentOptions().pop_id;
+    start.setTime(QTime(start.time().hour(), start.time().minute(), 0));
-        int const pop_carry_over = cfg->getPaymentOptions().pop_carry_over;
-        int const pop_time_step_config = cfg->getPaymentOptions().pop_time_step_config;
 
-        qCritical() << "              payment option id:" << pop_id;
+    int const pop_id = cfg->getPaymentOptions().pop_id;
-        qCritical() << "      payment option carry over:" << pop_carry_over;
+    int const pop_carry_over = cfg->getPaymentOptions().pop_carry_over;
-        qCritical() << "payment option time step config:" << pop_time_step_config;
+    int const pop_time_step_config = cfg->getPaymentOptions().pop_time_step_config;
 
-        if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::DYNAMIC) {
+    qCritical() << __PRETTY_FUNCTION__ << "             start parking time:" << start.toString(Qt::ISODate);
-            QDateTime start;
+    qCritical() << __PRETTY_FUNCTION__ << "              payment option id:" << pop_id;
-            start.setSecsSinceEpoch(startInMinutes * 60);
+    qCritical() << __PRETTY_FUNCTION__ << "      payment option carry over:" << pop_carry_over;
-            uint16_t timeStepCompensation = 0;
 
-            if (pop_carry_over) {
+    if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::DYNAMIC) {
-                int const pop_carry_over_time_range_id = cfg->getPaymentOptions().pop_carry_over_time_range_id;
+        //qCritical() << __PRETTY_FUNCTION__ << "payment option time step config:" << "TimeStepConfig::DYNAMIC";
-                QTime const carryOverTimeRangeFrom = cfg->TimeRange.find(pop_carry_over_time_range_id)->second.time_range_from;
-                QTime const carryOverTimeRangeTo = cfg->TimeRange.find(pop_carry_over_time_range_id)->second.time_range_to;
 
-                if (carryOverTimeRangeFrom.secsTo(carryOverTimeRangeTo) <= 60) { // carry over time point, usually 00:00:00
+        uint16_t timeStepCompensation = 0;
-                    if (carryOverTimeRangeFrom == QTime(0, 0, 0)) {
-                        for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
-                            int const durationId = itr->second.pra_payment_unit_id;
-                            auto search = cfg->Duration.find(durationId);
-                            if (search != cfg->Duration.end()) {
-                                ATBDuration duration = search->second;
-                                if (durationId == 1) {
-                                    QDateTime carryOver = start;
-                                    carryOver = carryOver.addDays(1);
-                                    carryOver.setTime(QTime(0, 0, 0));
 
-                                    int const timeStep = std::ceil(start.secsTo(carryOver) / 60.0);
+        if (pop_carry_over) {
-                                    if (timeStep < duration.pun_duration_min || timeStep > duration.pun_duration_max) {
+            int const pop_carry_over_time_range_id = cfg->getPaymentOptions().pop_carry_over_time_range_id;
-                                        qCritical()
+            QTime const carryOverTimeRangeFrom = cfg->TimeRange.find(pop_carry_over_time_range_id)->second.time_range_from;
-                                            << QString("ERROR timeStep (%1) < durationMin (%2) || timeStep (%3)) > durationMax (%4)")
+            QTime const carryOverTimeRangeTo = cfg->TimeRange.find(pop_carry_over_time_range_id)->second.time_range_to;
-                                                .arg(timeStep).arg(duration.pun_duration_min)
-                                                .arg(timeStep).arg(duration.pun_duration_max);
-                                        break;
-                                    }
-                                    qCritical() << "configured minimal parking time:" << cfg->getPaymentOptions().pop_min_time;
 
-                                    // set dynamic minimal parking time
+            if (carryOverTimeRangeFrom.secsTo(carryOverTimeRangeTo) <= 60) { // carry over time point, usually 00:00:00
-                                    cfg->getPaymentOptions().pop_min_time = timeStep;
+                if (carryOverTimeRangeFrom == QTime(0, 0, 0)) {
+                    for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
+                        int const durationId = itr->second.pra_payment_unit_id;
+                        auto search = cfg->Duration.find(durationId);
+                        if (search != cfg->Duration.end()) {
+                            ATBDuration duration = search->second;
+                            if (durationId == 1) {
+                                QDateTime carryOver = start;
+                                carryOver = carryOver.addDays(1);
+                                carryOver.setTime(QTime(0, 0, 0));
 
-                                    qCritical() << "  computed minimal parking time:" << cfg->getPaymentOptions().pop_min_time;
+                                int const timeStep = std::ceil(start.secsTo(carryOver) / 60.0);
-
+                                if (timeStep < duration.pun_duration_min || timeStep > duration.pun_duration_max) {
-                                    duration.pun_duration = timeStep;
+                                    qCritical()
-                                    timeStepCompensation = duration.pun_duration_max - duration.pun_duration;
+                                        << QString("ERROR timeStep (%1) < durationMin (%2) || timeStep (%3)) > durationMax (%4)")
-                                    timeSteps << duration.pun_duration;
+                                            .arg(timeStep).arg(duration.pun_duration_min)
-                                } else {
+                                            .arg(timeStep).arg(duration.pun_duration_max);
-                                    duration.pun_duration = duration.pun_duration_max - timeStepCompensation;
+                                    break;
-                                    timeSteps << duration.pun_duration;;
                                 }
+                                qCritical() << __PRETTY_FUNCTION__ << "configured minimal parking time:" << cfg->getPaymentOptions().pop_min_time;
 
-                                cfg->Duration.erase(search);
+                                // set dynamic minimal parking time
-                                cfg->Duration.insert(pair<int, ATBDuration>(duration.pun_id, duration));
+                                cfg->getPaymentOptions().pop_min_time = timeStep;
 
-                            } else { // if (search != cfg->Duration.end()) {
+                                qCritical() << __PRETTY_FUNCTION__ << "  computed minimal parking time:" << cfg->getPaymentOptions().pop_min_time;
-                               // TODO
+
+                                duration.pun_duration = timeStep;
+                                timeStepCompensation = duration.pun_duration_max - duration.pun_duration;
+                                m_timeSteps << duration.pun_duration;
+                            } else {
+                                duration.pun_duration = duration.pun_duration_max - timeStepCompensation;
+                                m_timeSteps << duration.pun_duration;;
                             }
+
+                            cfg->Duration.erase(search);
+                            cfg->Duration.insert(pair<int, ATBDuration>(duration.pun_id, duration));
+
+                        } else { // if (search != cfg->Duration.end()) {
+                           // TODO
                         }
-                    } else { // if (carryOverTimeRangeFrom == QTime(0, 0, 0)) {
-                        // TODO
                     }
-                } else { // if (carryOverTimeRangeFrom == carryOverTimeRangeTo) {
+                } else { // if (carryOverTimeRangeFrom == QTime(0, 0, 0)) {
                     // TODO
                 }
-            } else { // if (pop_carry_over) {
+            } else { // if (carryOverTimeRangeFrom == carryOverTimeRangeTo) {
                 // TODO
             }
-        } else {
+        } else { // if (pop_carry_over) {
-            for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr)
+            // TODO
-            {
+        }
-                int const durationId = itr->second.pra_payment_unit_id;
+    } else {
-                int const durationUnit = cfg->Duration.find(durationId)->second.pun_duration;
+        qCritical() << __PRETTY_FUNCTION__ << "payment option time step config:" << "TimeStepConfig::STATIC";
-                timeSteps << durationUnit;
+
-            }
+        for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr)
+        {
+            int const durationId = itr->second.pra_payment_unit_id;
+            int const durationUnit = cfg->Duration.find(durationId)->second.pun_duration;
+            m_timeSteps << durationUnit;
         }
     }
 
-    return timeSteps;
+    qCritical() << __PRETTY_FUNCTION__ << "NEW timeSteps:" << m_timeSteps;
+
+    return m_timeSteps;
 }
 
 uint32_t Calculator::GetPriceForTimeStep(Configuration *cfg, int timeStep) const {

main/main.cpp

@@ -54,18 +54,22 @@ int main() {
     cout << endl;
 
     if (isParsed) {
-        QDateTime start = QDateTime::currentDateTime();
+        int minParkingTime = get_minimal_parkingtime(&cfg);
-        start.setTime(QTime(start.time().hour(), start.time().minute(), 0));
+        QList<int> timeSteps = Calculator::GetInstance().GetTimeSteps(&cfg);
-        Calculator calculator(start);
-        QList<int> timeSteps = calculator.GetTimeSteps(&cfg);
         qCritical() << timeSteps;
+        int Down = 0;
+        int Up = 1;
+        //compute_next_timestep(&cfg, )
 
         for (int i=0; i<timeSteps.size(); ++i) {
-            uint32_t price = calculator.GetPriceForTimeStep(&cfg, timeSteps.at(i));
+            int nextTimeStep = compute_next_timestep(&cfg, timeSteps.at(i), Up);
-            uint32_t duration = calculator.GetDurationForPrice(&cfg, price);
+            qCritical() << "nextTimeStep" << nextTimeStep;
-            qCritical() << "nextTimeStep relative to start:"
+
-                        << duration << start.addSecs(duration * 60)
+//            uint32_t price = calculator.GetPriceForTimeStep(&cfg, timeSteps.at(i));
-                        << "(price so far:" << price << ")";
+//            uint32_t duration = calculator.GetDurationForPrice(&cfg, price);
+//            qCritical() << "nextTimeStep relative to start:"
+//                        << duration << start.addSecs(duration * 60)
+//                        << "(price so far:" << price << ")";
         }
     }
 #endif