Implement Model Refactoring

<UserStory> 1959: Model Refactoring </UserStory>

UserStory #1959

<Changes>
1. Replaced CSV-based User serialization and deserialization with SerializedUser record-based serialization for shared memory storage.
2. Implemented User::serialize() to convert User objects into fixed-size SerializedUser structures containing user details and enum values.
3. Implemented User::deserialize() to reconstruct User objects directly from SerializedUser records.
4. Updated User class interfaces to use SerializedUser types instead of std::string serialization APIs.
5. Removed legacy CSV serialization support, including CSV parsing logic and header generation functionality.
6. Added SerializedUser dependencies through SerializedRecords.h inclusion and forward declaration support.
</Changes>

<Test>
N/A
</Test>

<Review>
Sreeja Reghukumar, please review
</Review>

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem.vcxproj

@@ -157,7 +157,6 @@
     <ClInclude Include="core\patterns\Observer.h" />
     <ClInclude Include="core\patterns\Subject.h" />
     <ClInclude Include="datastores\DataStore.h" />
-    <ClInclude Include="datastores\DataStoreLockGuard.h" />
     <ClInclude Include="datastores\sharedmemory\FileHeader.h" />
     <ClInclude Include="datastores\sharedmemory\MappingInfo.h" />
     <ClInclude Include="datastores\sharedmemory\RecordState.h" />

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

@@ -588,37 +588,63 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }
 
 /*
-Function: initialize
-Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
-Parameters:
-    - None
-Returns:
-    - bool
-*/
-bool Controller::initialize()
-{
-    auto& dataStore = DataStore::getInstance();
-
-    if (!dataStore.initialize())
-    {
-        return false;
-    }
-    m_userManagementService.ensureAdminExists();
-    m_inventoryManagementService.sendLowStockAlerts();
-    m_paymentManagementService.sendPaymentReminders();
-    return true;
-}
-
-/*
-Function: shutdown
-Description: Shutdown the system, and do necessary cleanups
+Function: loadSystemData
+Description: Loads all system data from persistent storage into memory.
+             Invokes the respective management services to load users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
 Parameters:
     - None
 Returns:
     - void
 */
-void Controller::shutdown()
+void Controller::loadSystemData()
 {
-    auto& dataStore = DataStore::getInstance();
-    dataStore.shutdown();
+    m_userManagementService.loadUsers();
+    m_inventoryManagementService.loadInventoryItems();
+    m_serviceManagementService.loadServices();
+    m_serviceManagementService.loadComboPackages();
+    m_serviceManagementService.loadServiceBookings();
+    m_serviceManagementService.loadJobCards();
+    m_paymentManagementService.loadInvoices();
+    m_serviceManagementService.loadObservers();
+    m_paymentManagementService.loadObservers();
+    m_inventoryManagementService.loadObservers();
 }
+
+/*
+Function: saveSystemData
+Description: Saves all system data from memory back to persistent storage.
+             Invokes the respective management services to save users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::saveSystemData()
+{
+    m_userManagementService.saveUsers();
+    m_inventoryManagementService.saveInventoryItems();
+    m_serviceManagementService.saveServices();
+    m_serviceManagementService.saveComboPackages();
+    m_serviceManagementService.saveServiceBookings();
+    m_serviceManagementService.saveJobCards();
+    m_paymentManagementService.saveInvoices();
+    m_serviceManagementService.saveObservers();
+    m_paymentManagementService.saveObservers();
+    m_inventoryManagementService.saveObservers();
+}
+
+/*
+Function: runSystemChecks
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
+Parameter: None
+Return type: void
+*/
+void Controller::runSystemChecks()
+{
+    m_userManagementService.ensureAdminExists();
+    m_inventoryManagementService.sendLowStockAlerts();
+    m_paymentManagementService.sendPaymentReminders();
+}
+

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

@@ -70,6 +70,7 @@ public:
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
-    bool initialize();
-    void shutdown();
+    void loadSystemData();
+    void saveSystemData();
+    void runSystemChecks();
 };

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

@@ -228,22 +228,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
 {
-    auto users = loadRecords<User, SerializedUser>(m_users);
-    refreshCache(m_userCache, users);
-    auto& notifications = getNotifications();
-    int numberOfNotifications = m_notificationCache.getSize();
-    for (int index = 0; index < numberOfNotifications; index++)
-    {
-        Notification* notification = notifications.getValueAt(index).data;
-        const std::string& recipientUserId = notification->getRecipientUserId();
-        int userIndex = m_userCache.find(recipientUserId);
-        if (userIndex == -1)
-        {
-            throw std::runtime_error("Invalid recipient user ID");
-        }
-        User* user = m_userCache.getValueAt(userIndex).data;
-        user->addNotification(notification);
-    }
     return m_userCache;
 }
 
@@ -257,8 +241,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
 {
-    auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
-    refreshCache(m_notificationCache, notifications);
     return m_notificationCache;
 }
 
@@ -389,8 +371,6 @@ Returns:
 */
 void DataStore::saveUsers()
 {
-    saveRecords<User, SerializedUser>(m_users, m_userCache);
-    saveNotifications();
 }
 
 /*
@@ -403,7 +383,6 @@ Returns:
 */
 void DataStore::saveNotifications()
 {
-    saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
 }
 
 /*

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStore.h

@@ -195,10 +195,10 @@ void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
 
 /*
 Function: refreshCache
-Description: Refreshes the cache while preserving object addresses
-             for records that already exist. Existing objects are
-             updated in-place so that pointers held elsewhere remain
-             valid after the refresh.
+Description: Replaces the contents of an existing cache
+             with a newly loaded cache. Existing cached
+             objects are destroyed before ownership of
+             the new cache contents is transferred.
 Parameters:
     - cache: Existing cache to refresh.
     - refreshedCache: Newly loaded cache contents.
@@ -206,32 +206,8 @@ Returns:
     - None
 */
 template<typename TObject>
-void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cache, util::Map<std::string, TrackedRecord<TObject>>& refreshedCache)
+void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache)
 {
-    util::Map<std::string, TrackedRecord<TObject>> oldCache = cache;
-    cache.clear();
-    for (int index = 0; index < refreshedCache.getSize(); ++index)
-    {
-        const std::string& id = refreshedCache.getKeyAt(index);
-        TrackedRecord<TObject>& refreshedRecord = refreshedCache.getValueAt(index);
-        int oldIndex = oldCache.find(id);
-        if (oldIndex != -1)
-        {
-            TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
-            *oldRecord.data = *refreshedRecord.data;
-            oldRecord.slotIndex = refreshedRecord.slotIndex;
-            oldRecord.state = refreshedRecord.state;
-            delete refreshedRecord.data;
-            refreshedRecord.data = oldRecord.data;
-        }
-        cache.insert(id, refreshedRecord);
-    }
-    for (int index = 0; index < oldCache.getSize(); ++index)
-    {
-        const std::string& id = oldCache.getKeyAt(index);
-        if (cache.find(id) == -1)
-        {
-            delete oldCache.getValueAt(index).data;
-        }
-    }
+    clearCache(cache);
+    cache = refreshedCache;
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStoreLockGuard.h

@@ -1,28 +0,0 @@
-/*
-File: DataStoreLockGuard.h
-Description: Defines the DataStoreLockGuard class used to manage DataStore
-             locking and unlocking automatically within a scope.
-Author: Trenser
-Date: 12-June-2026
-*/
-
-#pragma once
-#include "DataStore.h"
-
-class DataStoreLockGuard
-{
-public:
-    explicit DataStoreLockGuard(DataStore& dataStore)
-        : m_dataStore(dataStore)
-    {
-        m_dataStore.lockDataStore();
-    }
-    ~DataStoreLockGuard()
-    {
-        m_dataStore.unlockDataStore();
-    }
-    DataStoreLockGuard(const DataStoreLockGuard&) = delete;
-    DataStoreLockGuard& operator=(const DataStoreLockGuard&) = delete;
-private:
-    DataStore& m_dataStore;
-};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/SharedMemory.cpp

@@ -10,7 +10,6 @@ Created: 11-June-2026
 */
 
 #include "SharedMemory.h"
-#include "Windows.h"
 #include "Config.h"
 
 /*

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/UserManagementService.cpp

@@ -20,9 +20,6 @@ Date:19-May-2026
 #include "UserManagementService.h"
 #include "Vector.h"
 #include "Validator.h"
-#include "Utility.h"
-#include "TrackedRecord.h"
-#include "DataStoreLockGuard.h"
 
 /*
 Function: ensureAdminExists
@@ -34,13 +31,12 @@ Return type: void
 */
 void UserManagementService::ensureAdminExists()
 {
-	DataStoreLockGuard lock(m_dataStore);
 	auto& usersMap = m_dataStore.getUsers();
 	int usersMapSize = usersMap.getSize();
 	bool isAdminFound = false;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = usersMap.getValueAt(index).data;
+		User* user = usersMap.getValueAt(index);
 		if (user && user->getUserType() == util::UserType::ADMIN)
 		{
 			isAdminFound = true;
@@ -77,9 +73,7 @@ void UserManagementService::createUser(const std::string& username, const std::s
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto usersMap = util::getObjects(trackedUsersMap);
+	auto& usersMap = m_dataStore.getUsers();
 	if (util::isUsernameDuplicate(username, usersMap))
 	{
 		throw std::runtime_error("Username already exists");
@@ -93,14 +87,13 @@ void UserManagementService::createUser(const std::string& username, const std::s
 		throw std::runtime_error("Phone already exists");
 	}
 	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
-	trackedUsersMap.insert(newUser->getId(), util::createNewRecord(newUser));
+	usersMap.insert(newUser->getId(), newUser);
 	paymentManagementService.attach(newUser);
 	serviceManagementService.attach(newUser);
 	if (newUser->getUserType() == util::UserType::ADMIN)
 	{
 		inventoryManagementService.attach(newUser);
 	}
-	m_dataStore.saveUsers();
 }
 
 /*
@@ -114,24 +107,19 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto usersMap = util::getObjects(trackedUsersMap);
-	int index = trackedUsersMap.find(userID);
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
 	if (index == -1)
 	{
 		throw std::runtime_error("User does not exist!\n");
 	}
-	User* user = trackedUsersMap.getValueAt(index).data;
-	bool isModified = false;
+	User* user = usersMap.getValueAt(index);
 	if (email != user->getEmail())
 	{
 		if (util::isEmailDuplicate(email, usersMap))
 		{
 			throw std::runtime_error("Email already exists!\n");
 		}
-		user->setEmail(email);
-		isModified = true;
 	}
 	if (phone != user->getPhone())
 	{
@@ -139,14 +127,9 @@ void UserManagementService::updateUserDetails(const std::string& userID, const s
 		{
 			throw std::runtime_error("Phone number already exists!\n");
 		}
-		user->setPhone(phone);
-		isModified = true;
-	}
-	if (isModified)
-	{
-		trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-		m_dataStore.saveUsers();
 	}
+	user->setEmail(email);
+	user->setPhone(phone);
 }
 
 /*
@@ -161,13 +144,12 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers(); 
-	if (trackedUsersMap.find(userID) == -1)
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = trackedUsersMap[userID].data;
+	User* user = usersMap[userID];
 	if (user)
 	{
 		auto& notifications = user->getNotifications();
@@ -187,41 +169,97 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 
 /*
 Function: deleteNotification
-Description: Marks a specific notification associated with a given user
-			 as inactive.
+Description: Deletes a specific notification associated with a given user ID.
 Parameters:
 	- notificationID: The unique ID of the notification to be deleted.
 	- userID: The unique ID of the user whose notification is to be deleted.
 Returns:
 	- void
 Throws:
-	- std::runtime_error if no user is found with the given UserID or
-	  if no notification is found with the given NotificationID.
+	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	int userIndex = trackedUsersMap.find(userID);
-	if (userIndex == -1)
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = trackedUsersMap.getValueAt(userIndex).data;
+	User* user = usersMap[userID];
 	auto& notifications = user->getNotifications();
 	if (notifications.find(notificationID) == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	int notificationIndex = trackedNotificationsMap.find(notificationID);
-	if (notificationIndex == -1)
-	{
-		throw std::runtime_error("No notification found with given NotificationID");
-	}
-	notifications[notificationID]->setState(util::State::INACTIVE);
-	trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
-	m_dataStore.saveNotifications();
+	notifications.remove(notificationID);
+}
+
+/*
+Function: loadUsers
+Description: Loads users and notifications from persistent storage into the datastore.
+             Validates that each notification’s recipient exists and attaches the
+             notification to the corresponding user.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a notification recipient user ID is invalid
+*/
+void UserManagementService::loadUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    auto usersMap = userFileManager.load();
+    auto notificationsMap = notificationFileManager.load();
+    int numberOfUsers = usersMap.getSize();
+    int numberOfNotifications = notificationsMap.getSize();
+    for (int index = 0; index < numberOfUsers; index++)
+    {
+        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
+    }
+    for (int index = 0; index < numberOfNotifications; index++)
+    {
+        Notification* notification = notificationsMap.getValueAt(index);
+        const std::string& recipientUserId = notification->getRecipientUserId();
+        int userIndex = users.find(recipientUserId);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid recipient user ID");
+        }
+        User* user = users.getValueAt(userIndex);
+        user->addNotification(notification);
+    }
+}
+
+/*
+Function: saveUsers
+Description: Saves users and their notifications from the datastore to persistent storage.
+             Collects notifications from all users into a single map before saving.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void UserManagementService::saveUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    util::Map<std::string, Notification*> notifications;
+    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
+    {
+        User* user = users.getValueAt(userIndex);
+        auto& userNotifications = user->getNotifications();
+        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
+        {
+            notifications[userNotifications.getKeyAt(notificationIndex)] =
+                userNotifications.getValueAt(notificationIndex);
+        }
+    }
+    userFileManager.save(users);
+    notificationFileManager.save(notifications);
 }
 
 /*
@@ -232,9 +270,7 @@ Return type: util::Map<std::string, User*>
 */
 util::Map<std::string, User*> UserManagementService::getUsers()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto users = util::getObjects(m_dataStore.getUsers());
-	return users;
+	return m_dataStore.getUsers();
 }
 
 /*
@@ -245,12 +281,10 @@ Return type: User*
 */
 User* UserManagementService::getUser(const std::string& userID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.find(userID);
+	int index = m_dataStore.getUsers().find(userID);
 	if (index != -1)
 	{
-		return trackedUsersMap.getValueAt(index).data;
+		return m_dataStore.getUsers().getValueAt(index);
 	}
 	return nullptr;
 }
@@ -266,53 +300,35 @@ void UserManagementService::removeUser(const std::string& userID)
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.find(userID);
+	int index = m_dataStore.getUsers().find(userID);
 	if (index != -1)
 	{
-		User* user = trackedUsersMap.getValueAt(index).data;
+		User* user = m_dataStore.getUsers().getValueAt(index);
 		if (user != nullptr)
 		{
 			if (user->getUserType() == util::UserType::CUSTOMER)
 			{
-				serviceManagementService.cancelCustomerServiceBookings(userID);
+				serviceManagementService.cancelCustomerServiceBookings(userID);	
 			}
 			if (user->getUserType() == util::UserType::TECHNICIAN)
 			{
 				serviceManagementService.cancelTechnicianJobs(userID);
 			}
+			user->setState(util::State::INACTIVE);
 			inventoryManagementService.detach(user);
 			paymentManagementService.detach(user);
 			serviceManagementService.detach(user);
-			user->setState(util::State::INACTIVE);
-			trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-			m_dataStore.saveUsers();
 		}
 	}
 }
 
-/*
-Function: getUsers
-Description: Retrieves all active users of the specified type from
-			 the DataStore.
-Parameters:
-	- type: The user type to filter by
-			(ADMIN, CUSTOMER, or TECHNICIAN).
-Returns:
-	- util::Map<std::string, User*>:
-	  Collection of active users matching the specified type,
-	  keyed by user ID.
-*/
-util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type) 
+util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	util::Map<std::string, User*> currentUsers = util::getObjects(trackedUsersMap);
+	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
 	util::Map<std::string, User*> filteredUsersMap;
-	for (int index = 0; index < currentUsers.getSize(); index++)
+	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
 	{
-		User* currentUser = currentUsers.getValueAt(index);
+		User* currentUser = currentUsers.getValueAt(iterator);
 		if (currentUser && currentUser->getState() == util::State::ACTIVE && currentUser->getUserType() == type)
 		{
 			filteredUsersMap.insert(currentUser->getId(), currentUser);

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/UserManagementService.h

@@ -31,4 +31,6 @@ public:
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);
     void ensureAdminExists();
+    void loadUsers();
+    void saveUsers();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Utility.h

@@ -99,80 +99,4 @@ namespace util
         auto observerIDs = service->getObserverIDs();
         util::saveRecords(filePath, observerIDs);
     }
-
-    template<typename TObject>
-    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
-
-    template<typename TObject>
-    Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
-
-    template<typename TObject>
-    TrackedRecord<TObject> createNewRecord(TObject* object);
-}
-
-/*
-Function: getObjects
-Description: Extracts the object pointers from a tracked-record
-             collection and returns them as a map keyed by the
-             same identifiers.
-Parameters:
-    - trackedRecords: Collection of tracked records.
-Returns:
-    - Map<std::string, TObject*>: Collection of object pointers.
-*/
-template<typename TObject>
-util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
-{
-    util::Map<std::string, TObject*> objects;
-    for (int index = 0; index < trackedRecords.getSize(); ++index)
-    {
-        const std::string& key = trackedRecords.getKeyAt(index);
-        TObject* object = trackedRecords.getValueAt(index).data;
-        objects.insert(key, object);
-    }
-    return objects;
-}
-
-/*
-Function: getConstObjects
-Description: Extracts the object pointers from a tracked-record
-             collection and returns them as a read-only map
-             keyed by the same identifiers.
-Parameters:
-    - trackedRecords: Collection of tracked records.
-Returns:
-    - Map<std::string, const TObject*>:
-      Collection of read-only object pointers.
-*/
-template<typename TObject>
-util::Map<std::string, const TObject*> util::getConstObjects(
-    const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
-{
-    util::Map<std::string, const TObject*> objects;
-    for (int index = 0; index < trackedRecords.getSize(); ++index)
-    {
-        const std::string& key = trackedRecords.getKeyAt(index);
-        const TObject* object = trackedRecords.getValueAt(index).data;
-        objects.insert(key, object);
-    }
-    return objects;
-}
-
-/*
-Function: createNewRecord
-Description: Creates a tracked record for a newly created
-             object. The record is initialized with
-             NEW_RECORD state.
-Parameters:
-    - object: Pointer to the newly created object.
-Returns:
-    - TrackedRecord<TObject>: Initialized tracked record.
-*/
-template<typename TObject>
-TrackedRecord<TObject> util::createNewRecord(TObject* object)
-{
-    TrackedRecord<TObject> record;
-    record.data = object;
-    record.state = RecordState::NEW_RECORD;
-    return record;
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/UserInterface.cpp

@@ -27,11 +27,8 @@ void UserInterface::run()
 {
 	try
 	{
-		if (!m_controller.initialize())
-		{
-			std::cout << "Error: Failed to initialize the system!";
-			return;
-		}
+		m_controller.loadSystemData();
+		m_controller.runSystemChecks();
 		bool isMenuActive = true;
 		while (isMenuActive)
 		{
@@ -52,7 +49,7 @@ void UserInterface::run()
 				util::pressEnter();
 			}
 		}
-		m_controller.shutdown();
+		m_controller.saveSystemData();
 	}
 	catch (const std::invalid_argument& exception)
 	{