Fix combo package null handling and cleanup initialization

- Added null checks in combo package display/selection flows
- Replaced unnecessary copies with references
- Zero-initialized SerializedObserver
- Initialized event handle array

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/controllers/Controller.cpp

@@ -234,6 +234,17 @@ void Controller::removeInventoryItem(const std::string& inventoryItemID)
     m_inventoryManagementService.removeInventoryItem(inventoryItemID);
 }
 
+/*
+Function: removeServiceBooking
+Description: Removes a service booking from the service management system by its booking ID.
+Parameter: const std::string& bookingID - ID of the service booking
+Return type: void
+*/
+void Controller::removeServiceBooking(const std::string& bookingID)
+{
+    m_serviceManagementService.removeServiceBooking(bookingID);
+}
+
 /*
 Function: addInventoryItemStock
 Description: Adds stock to an existing inventory item in the inventory management service.
@@ -265,6 +276,7 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
     return readOnlyServiceBookings;
 }
 
+
 /*
 Function: getServiceBookingsByUser
 Description: Retrieves all service bookings for a specific user.

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/controllers/Controller.h

@@ -58,6 +58,7 @@ public:
     util::Map<std::string, const User*> getUsers(util::UserType userType);
     void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
+    void removeServiceBooking(const std::string& bookingID);
     void removeService(const std::string& serviceID);
     util::Map<std::string, const JobCard*> getJobCardsByUser();
     void updateJobStatus(const std::string& jobID);

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStore.cpp

@@ -358,7 +358,7 @@ util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBook
             {
                 throw std::runtime_error("Invalid service index.");
             }
-            auto currentService = services.getValueAt(serviceIndex);
+            auto& currentService = services.getValueAt(serviceIndex);
             servicesInBooking[currentServiceId] = currentService.data;
         }
         serviceBooking->setServices(servicesInBooking);
@@ -369,7 +369,7 @@ util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBook
             {
                 throw std::runtime_error("Invalid user index.");
             }
-            auto customer = users.getValueAt(userIndex);
+            auto& customer = users.getValueAt(userIndex);
             serviceBooking->setCustomer(customer.data);
         }
         if (!serviceBooking->getAssignedTechnicianId().empty())
@@ -379,7 +379,7 @@ util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBook
             {
                 throw std::runtime_error("Invalid technician index.");
             }
-            auto technician = users.getValueAt(technicianIndex);
+            auto& technician = users.getValueAt(technicianIndex);
             serviceBooking->setAssignedTechnician(technician.data);
         }
     }
@@ -415,7 +415,7 @@ util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
         {
             throw std::runtime_error("Invalid booking ID: " + bookingId);
         }
-        auto trackedBooking = serviceBookings.getValueAt(bookingIndex);
+        auto& trackedBooking = serviceBookings.getValueAt(bookingIndex);
         jobCard->setBooking(trackedBooking.data);
         const std::string& serviceId = jobCard->getServiceId();
         int serviceIndex = services.find(serviceId);
@@ -423,7 +423,7 @@ util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
         {
             throw std::runtime_error("Invalid service ID: " + serviceId);
         }
-        auto trackedService = services.getValueAt(serviceIndex);
+        auto& trackedService = services.getValueAt(serviceIndex);
         jobCard->setService(trackedService.data);
         const std::string& technicianId = jobCard->getTechnicianId();
         if (!technicianId.empty())
@@ -433,7 +433,7 @@ util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
             {
                 throw std::runtime_error("Invalid technician ID: " + technicianId);
             }
-            auto trackedTechnician = users.getValueAt(technicianIndex);
+            auto& trackedTechnician = users.getValueAt(technicianIndex);
             jobCard->setTechnician(trackedTechnician.data);
         }
     }
@@ -691,7 +691,7 @@ void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*
     SharedMemory::setRecordCount(mapping, observerCount);
     for (size_t index = 0; index < observerCount; index++)
     {
-        SerializedObserver serializedObserver;
+        SerializedObserver serializedObserver{};
         User* user = observers.getValueAt(static_cast<int>(index));
         strcpy_s(serializedObserver.id, sizeof(serializedObserver.id), user->getId().c_str());
         SerializedObserver* destination = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/ServiceManagementService.cpp

@@ -26,7 +26,6 @@ Date:19-May-2026
 #include "UserManagementService.h"
 #include "DataStoreLockGuard.h"
 #include "Utility.h"
-#include "DataStoreLockGuard.h"
 #include "EventManager.h"
 
 /*
@@ -141,6 +140,7 @@ void ServiceManagementService::purchaseComboPackage(const std::string& comboPack
     std::string title = "Combo Package Service Booking succeeded";
     std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
     sendNotification(authenticatedUser, title, message);
+    m_dataStore.saveServiceBookings();
     notifyAllAdmins("New Combo Package Order Available", "A new combo package order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }
 
@@ -629,11 +629,23 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     DataStoreLockGuard lock(m_dataStore);
 	UserManagementService m_userManagementService;
 	ServiceBooking* currentBooking = getServiceBooking(bookingID);
+    if (currentBooking == nullptr)
+    {
+        throw std::runtime_error("Service Booking not available");
+    }
+    if (currentBooking->getStatus() == util::ServiceJobStatus::CANCELLED)
+    {
+        throw std::runtime_error("Cannot create job card. Service Booking was cancelled!");
+    }
 	auto& currentTrackedJobCards = m_dataStore.getJobCards();
-	if (currentBooking == nullptr)
+    auto& currentTrackedInventoryItems = m_dataStore.getInventoryItems();
-	{
+    auto& currentTrackedServiceBookings = m_dataStore.getServiceBookings();
-		throw std::runtime_error("Service Booking not available");
+    int currentTrackedServiceBookingIndex = currentTrackedServiceBookings.find(bookingID);
-	}
+    if (currentTrackedServiceBookingIndex == -1)
+    {
+        throw std::runtime_error("Invalid service booking id.");
+    }
+    auto& currentTrackedServiceBooking = currentTrackedServiceBookings.getValueAt(currentTrackedServiceBookingIndex);
 	auto& currentServices = currentBooking->getServices();
 	if (currentServices.find(serviceID) == -1)
 	{
@@ -658,10 +670,18 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
 	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
 	{
 		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
+        const std::string& currentInventoryItemId = inventoryItems.getKeyAt(iterator);
 		if (currentInventoryItem)
 		{
+            int trackedCurrentInventoryItemIndex = currentTrackedInventoryItems.find(currentInventoryItemId);
+            if (trackedCurrentInventoryItemIndex == -1)
+            {
+                throw std::runtime_error("Invalid inventory item index.");
+            }
+            auto& trackedCurrentInventoryItem = currentTrackedInventoryItems.getValueAt(trackedCurrentInventoryItemIndex);
 			int currentStockQuantity = currentInventoryItem->getQuantity();
 			currentInventoryItem->setQuantity(currentStockQuantity - 1);
+            trackedCurrentInventoryItem.state = RecordState::MODIFIED;
 		}
 	}
 	currentBooking->setAssignedTechnician(selectedTechnician);
@@ -670,6 +690,7 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     {
         currentBooking->setStatus(util::ServiceJobStatus::STARTED);
     }
+    currentTrackedServiceBooking.state = RecordState::MODIFIED;
 	std::string title = "Job card created";
 	std::string message = "Job card created for the service and you are assigned for that.";
 	JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
@@ -686,6 +707,8 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     message = "A technician has been assigned to your Service Booking with ID " + bookingID;
     sendNotification(currentBooking->getCustomer(), title, message);
     m_dataStore.saveJobCards();
+    m_dataStore.saveServiceBookings();
+    m_dataStore.saveInventoryItems();
 }
 
 /*
@@ -807,6 +830,61 @@ void ServiceManagementService::removeService(const std::string& serviceID)
     m_dataStore.saveComboPackages();
 }
 
+/*
+Function: removeServiceBooking
+Description: Removes a pending service booking by its ID.
+             Cancels only if status is PENDING, otherwise throws exceptions
+             for invalid states. Sends notification to the customer and
+             persists changes.
+Parameter: const std::string& bookingID - ID of the service booking
+Return type: void
+*/
+void ServiceManagementService::removeServiceBooking(const std::string& bookingID)
+{
+    DataStoreLockGuard lock(m_dataStore);
+    auto& trackedServiceBookings = m_dataStore.getServiceBookings();
+    bool serviceBookingRemoved = false;
+    for (int iterator = 0; iterator < trackedServiceBookings.getSize(); iterator++)
+    {
+        auto& currentTrackedServiceBooking = trackedServiceBookings.getValueAt(iterator);
+        ServiceBooking* currentServiceBooking = currentTrackedServiceBooking.data;
+        if (currentServiceBooking && currentServiceBooking->getId() == bookingID)
+        {
+            if (currentServiceBooking->getStatus() == util::ServiceJobStatus::PENDING)
+            {
+                const std::string title = "Service Booking cancelled.";
+                const std::string message = "Service Booking of id " + bookingID + " successfully cancelled.";
+                currentServiceBooking->setStatus(util::ServiceJobStatus::CANCELLED);
+                currentTrackedServiceBooking.state = RecordState::MODIFIED;
+                serviceBookingRemoved = true;
+                sendNotification(currentServiceBooking->getCustomer(), title, message);
+                break;
+            }
+            else if(currentServiceBooking->getStatus() == util::ServiceJobStatus::COMPLETED)
+            {
+                throw std::runtime_error("Unable to cancel completed service booking.");
+            }
+            else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::STARTED)
+            {
+                throw std::runtime_error("Unable to cancel started service booking.");
+            }
+            else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
+            {
+                throw std::runtime_error("Unable to cancel currently Inprogress service booking.");
+            }
+            else
+            {
+                throw std::runtime_error("Service Booking already cancelled.");
+            }
+        }
+    }
+    if (!serviceBookingRemoved)
+    {
+        throw std::runtime_error("Unable to cancel service booking.");
+    }
+    m_dataStore.saveServiceBookings();
+}
+
 /*
 Function: getServiceBookings (overloaded)
 Description: Retrieves all service bookings for a specific customer.
@@ -901,44 +979,44 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
     AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
-	AuthenticationManagementService authenticationManagementService;
+    AuthenticationManagementService authenticationManagementService;
-	PaymentManagementService paymentManagementService;
+    PaymentManagementService paymentManagementService;
-	bool jobStatusUpdated = false, serviceBookingCompleted;
+    bool jobStatusUpdated = false, serviceBookingCompleted;
-	JobCard* currentJob;
+    User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
-	User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
+    if (currentTechnician == nullptr)
-	if (currentTechnician == nullptr)
+    {
-	{
+        throw std::runtime_error("Unable to fetch current technician.");
-		throw std::runtime_error("Unable to fetch current technician.");
+    }
-	}
+    util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
-	util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
+    if (currentAssignedJobs.getSize() == 0)
-	if (currentAssignedJobs.getSize() == 0)
+    {
-	{
+        throw std::runtime_error("No job cards assigned to the technician.");
-		throw std::runtime_error("No job cards assigned to the technician.");
+    }
-	}
     auto& trackedJobCards = m_dataStore.getJobCards();
     auto& trackedServiceBookings = m_dataStore.getServiceBookings();
-	if (currentAssignedJobs.find(jobID) != -1)
+    if (currentAssignedJobs.find(jobID) != -1)
-	{
+    {
         int jobIndex = trackedJobCards.find(jobID);
         if (jobIndex == -1)
         {
             throw std::runtime_error("Unable to fetch current job.");
         }
-		currentJob = currentAssignedJobs.getValueAt(currentAssignedJobs.find(jobID));
+        auto& trackedCurrentJob = trackedJobCards.getValueAt(jobIndex);
-		if (currentJob == nullptr)
+        JobCard* currentJob = trackedCurrentJob.data;
-		{
+        if (currentJob == nullptr)
-			throw std::runtime_error("Unable to fetch current job.");
+        {
-		}
+            throw std::runtime_error("Unable to fetch current job.");
-		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+        }
-		{
+        if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
-			currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
+        {
-            trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
+            currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
-			jobStatusUpdated = true;
+            trackedCurrentJob.state = RecordState::MODIFIED;
-		}
+            jobStatusUpdated = true;
+        }
         else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
         {
             currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
-            trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
+            trackedCurrentJob.state = RecordState::MODIFIED;
             jobStatusUpdated = true;
             serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
             if (serviceBookingCompleted)
@@ -952,15 +1030,15 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
                 sendNotification(currentJob->getBooking()->getCustomer(), title, message);
             }
         }
-	}
+    }
-	else
+    else
-	{
+    {
-		throw std::runtime_error("Failed to update job status. Job may already be completed.");
+        throw std::runtime_error("Failed to update job status. Job may already be completed.");
-	}
+    }
-	if (!jobStatusUpdated)
+    if (!jobStatusUpdated)
-	{
+    {
-		throw std::runtime_error("Failed to update job status. Job may already be completed.");
+        throw std::runtime_error("Failed to update job status. Job may already be completed.");
-	}
+    }
     m_dataStore.saveJobCards();
     m_dataStore.saveServiceBookings();
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/ServiceManagementService.h

@@ -35,6 +35,7 @@ public:
     void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
+    void removeServiceBooking(const std::string& bookingID);
     util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
     void updateJobStatus(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/CustomerMenu.cpp

@@ -51,11 +51,12 @@ void CustomerMenu::showMenu()
                 << "\n3. Update Profile"
                 << "\n4. Change Password"
                 << "\n5. View Service History"
-                << "\n6. Complete Payments"
+                << "\n6. Cancel Service Booking"
-                << "\n7. View Invoices"
+                << "\n7. Complete Payments"
-                << "\n8. View Notifications"
+                << "\n8. View Invoices"
-                << "\n9. Configure Notifications"
+                << "\n9. View Notifications"
-                << "\n10. Logout"
+                << "\n10. Configure Notifications"
+                << "\n11. Logout"
                 << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
@@ -103,18 +104,21 @@ bool CustomerMenu::handleOperation(int choice)
         viewServiceHistory();
         break;
     case 6:
-        completePayments();
+        cancelServiceBooking();
         break;
     case 7:
-        viewInvoices();
+        completePayments();
         break;
     case 8:
-        viewNotifications();
+        viewInvoices();
         break;
     case 9:
-        configureNotifications();
+        viewNotifications();
         break;
     case 10:
+        configureNotifications();
+        break;
+    case 11:
         logout();
         return false;
     default:
@@ -333,6 +337,46 @@ void CustomerMenu::viewServiceHistory()
     util::pressEnter();
 }
 
+/*
+Function: cancelServiceBooking
+Description: Allows the customer to cancel a pending service booking.
+             Displays the list of active bookings, lets the user select one,
+             and removes it from the system. If no bookings are available,
+             an appropriate message is shown.
+Parameter: None
+Return type: void
+*/
+void CustomerMenu::cancelServiceBooking()
+{
+    util::clear();
+    std::cout << "Cancel Service Booking\n";
+    const User* currentUser = m_controller.getAuthenticatedUser();
+    std::string currentUserID = currentUser->getId();
+    util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
+    util::Map<int, const ServiceBooking*> serviceBookingsMap;
+    auto currentPendingServiceBookings = filterActiveServiceBookings(serviceBookingsByCurrentUser);
+    int bookingsSize = currentPendingServiceBookings.getSize();
+    if (listServiceBookings(currentPendingServiceBookings, bookingsSize, serviceBookingsMap))
+    {
+        const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
+        if (selectedService)
+        {
+            m_controller.removeServiceBooking(selectedService->getId());
+            std::cout << "Cancelled Service booking of id " + selectedService->getId() << std::endl << std::endl;
+        }
+        else
+        {
+            std::cout << "Invalid service booking index.\n\n";
+            return;
+        }
+    }
+    else
+    {
+        std::cout << "No pending service bookings available.\n\n";
+    }
+    util::pressEnter();
+}
+
 /*
 Function: completePayments
 Description: Allows the customer to complete pending payments for invoices.

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/CustomerMenu.h

@@ -28,5 +28,6 @@ public:
     void completePayments();
     void viewInvoices();
     void viewNotifications();
+    void cancelServiceBooking();
     void configureNotifications();
-};
+};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/Menu.cpp

@@ -67,7 +67,7 @@ Return type: void
 */
 void Menu::eventListenerLoop()
 {
-    HANDLE handles[3];
+    HANDLE handles[3] = { NULL, NULL, NULL };
     handles[0] = m_accountDisabledEvent;
     handles[1] = m_notificationAvailableEvent;
     handles[2] = m_shutdownEvent;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/MenuHelper.h

@@ -588,7 +588,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                     << util::getPaymentStatusString(selectedInvoice->getStatus()) << std::endl;
                 std::cout << std::left << std::setw(20) << "Payment Mode:"
                     << util::getPaymentModeString(selectedInvoice->getPaymentMethod()) << std::endl;
-                auto inventoryItemsInInvoice = selectedInvoice->getParts();
+                auto& inventoryItemsInInvoice = selectedInvoice->getParts();
                 if (inventoryItemsInInvoice.isEmpty())
                 {
                     std::cout << "No inventory items used.\n\n";
@@ -597,7 +597,6 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                 std::cout << "\nItems Used:\n";
                 std::cout << std::left
                     << std::setw(20) << "ItemName"
-                    << std::setw(10) << "Quantity"
                     << std::setw(10) << "Price"
                     << std::endl;
                 std::cout << std::string(40, '-') << std::endl;
@@ -606,7 +605,6 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                     InventoryItem* currentItem = inventoryItemsInInvoice.getValueAt(iterator);
                     std::cout << std::left
                         << std::setw(20) << currentItem->getPartName()
-                        << std::setw(10) << currentItem->getQuantity()
                         << std::setw(10) << currentItem->getPrice()
                         << std::endl;
                 }
@@ -1146,15 +1144,18 @@ inline void displayAllComboPackages(util::Map<std::string, const ComboPackage*>
     for (int index = 0; index < comboPackages.getSize(); index++)
     {
         const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
+        if (currentComboPackage) 
         {
-            continue;
+            if (currentComboPackage->getState() != util::State::ACTIVE)
+            {
+                continue;
+            }
+            std::cout << std::left
+                << std::setw(15) << currentComboPackage->getId()
+                << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
+                << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+                << std::endl;
         }
-        std::cout << std::left
-            << std::setw(15) << currentComboPackage->getId()
-            << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
-            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-            << std::endl;
     }
 }
 
@@ -1180,18 +1181,21 @@ inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::s
     for (int index = 0; index < comboPackages.getSize(); index++)
     {
         const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
+        if (currentComboPackage)
         {
-            continue;
+            if (currentComboPackage->getState() != util::State::ACTIVE)
+            {
+                continue;
+            }
+            activeComboPackages.insert(currentIndex, currentComboPackage);
+            std::cout << std::left
+                << std::setw(10) << currentIndex
+                << std::setw(15) << currentComboPackage->getId()
+                << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
+                << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+                << std::endl;
+            currentIndex++;
         }
-        activeComboPackages.insert(currentIndex, currentComboPackage);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentComboPackage->getId()
-            << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
-            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-            << std::endl;
-        currentIndex++;
     }
     if (activeComboPackages.getSize() == 0)
     {