337 lines
9.2 KiB
C++
337 lines
9.2 KiB
C++
/*
|
|
File: Service.cpp
|
|
Description: Implements the Service class which represents a vehicle service in the Vehicle Service Management System.
|
|
Provides constructors, accessors, and mutators for service details such as ID, name, required inventory items,
|
|
labor cost, and state.
|
|
Author: Trenser
|
|
Date: 19-May-2026
|
|
*/
|
|
|
|
#include <sstream>
|
|
#include "Service.h"
|
|
#include "InventoryItem.h"
|
|
#include "StringHelper.h"
|
|
#include "Factory.h"
|
|
|
|
int Service::m_uid = 0;
|
|
|
|
/*
|
|
Function: Service
|
|
Description: Default constructor that initializes a new service with a unique ID,
|
|
active state, and zero labor cost.
|
|
Parameters:
|
|
- None
|
|
Returns:
|
|
- A new Service object.
|
|
*/
|
|
Service::Service()
|
|
: m_id("SRV" + std::to_string(++m_uid)),
|
|
m_status(util::State::ACTIVE),
|
|
m_laborCost(0.0) {}
|
|
|
|
/*
|
|
Function: Service
|
|
Description: Parameterized constructor that initializes a new service with a unique ID and specified details.
|
|
Parameters:
|
|
- name: Name of the service.
|
|
- requiredInventoryItems: Map of inventory items required for the service.
|
|
- laborCost: Labor cost associated with the service.
|
|
Returns:
|
|
- A new Service object.
|
|
*/
|
|
Service::Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost)
|
|
: m_id("SRV" + std::to_string(++m_uid)),
|
|
m_name(name),
|
|
m_requiredInventoryItems(requiredInventoryItems),
|
|
m_status(util::State::ACTIVE),
|
|
m_laborCost(laborCost)
|
|
{
|
|
int numberOfInventoryItems = m_requiredInventoryItems.getSize();
|
|
auto inventoryItemPointers = m_requiredInventoryItems.getValues();
|
|
for (int index = 0; index < numberOfInventoryItems; index++)
|
|
{
|
|
m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
|
|
}
|
|
}
|
|
|
|
/*
|
|
Function: Service (parameterized constructor with ID)
|
|
Description: Initializes a service with an existing ID, name, inventory item IDs,
|
|
labor cost, and state. Updates UID tracking based on ID.
|
|
Parameters:
|
|
- id: const std::string&, unique service ID
|
|
- name: const std::string&, name of the service
|
|
- requiredInventoryItemIDs: const util::Vector<std::string>&, IDs of required inventory items
|
|
- laborCost: double, labor cost of the service
|
|
- status: util::State, state of the service (ACTIVE/INACTIVE)
|
|
Returns:
|
|
- A new Service object
|
|
*/
|
|
Service::Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State status)
|
|
: m_id(id),
|
|
m_name(name),
|
|
m_requiredInventoryItemIDs(requiredInventoryItemIDs),
|
|
m_status(status),
|
|
m_laborCost(laborCost)
|
|
{
|
|
int idNumber = util::extractNumber(m_id);
|
|
if (idNumber > m_uid)
|
|
{
|
|
m_uid = idNumber;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Function: getId
|
|
Description: Retrieves the unique ID of the service.
|
|
Returns:
|
|
- const std::string& representing the service ID.
|
|
*/
|
|
const std::string& Service::getId() const
|
|
{
|
|
return m_id;
|
|
}
|
|
|
|
/*
|
|
Function: getName
|
|
Description: Retrieves the name of the service.
|
|
Returns:
|
|
- const std::string& representing the service name.
|
|
*/
|
|
const std::string& Service::getName() const
|
|
{
|
|
return m_name;
|
|
}
|
|
|
|
/*
|
|
Function: getRequiredInventoryItemIDs
|
|
Description: Retrieves the IDs of required inventory items for the service.
|
|
Parameters:
|
|
- None
|
|
Returns:
|
|
- const util::Vector<std::string>&: Inventory item IDs
|
|
*/
|
|
const util::Vector<std::string>& Service::getRequiredInventoryItemIDs() const
|
|
{
|
|
return m_requiredInventoryItemIDs;
|
|
}
|
|
|
|
/*
|
|
Function: getRequiredInventoryItems
|
|
Description: Retrieves the map of inventory items required for the service.
|
|
Returns:
|
|
- const util::Map<std::string, InventoryItem*>& representing the required inventory items.
|
|
*/
|
|
const util::Map<std::string, InventoryItem*>& Service::getRequiredInventoryItems() const
|
|
{
|
|
return m_requiredInventoryItems;
|
|
}
|
|
|
|
/*
|
|
Function: getLaborCost
|
|
Description: Retrieves the labor cost associated with the service.
|
|
Returns:
|
|
- double representing the labor cost.
|
|
*/
|
|
double Service::getLaborCost() const
|
|
{
|
|
return m_laborCost;
|
|
}
|
|
|
|
/*
|
|
Function: getState
|
|
Description: Retrieves the current state (ACTIVE/INACTIVE) of the service.
|
|
Returns:
|
|
- util::State representing the service state.
|
|
*/
|
|
util::State Service::getState() const
|
|
{
|
|
return m_status;
|
|
}
|
|
|
|
/*
|
|
Function: setId
|
|
Description: Sets the unique ID of the service.
|
|
Parameters:
|
|
- id: New service ID string.
|
|
Returns:
|
|
- void
|
|
*/
|
|
void Service::setId(const std::string& id)
|
|
{
|
|
m_id = id;
|
|
}
|
|
|
|
/*
|
|
Function: setName
|
|
Description: Sets the name of the service.
|
|
Parameters:
|
|
- name: New service name string.
|
|
Returns:
|
|
- void
|
|
*/
|
|
void Service::setName(const std::string& name)
|
|
{
|
|
m_name = name;
|
|
}
|
|
|
|
/*
|
|
Function: setRequiredInventoryItems
|
|
Description: Sets the inventory items required for the service.
|
|
Parameters:
|
|
- requiredInventoryItems: Map of inventory items.
|
|
Returns:
|
|
- void
|
|
*/
|
|
void Service::setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems)
|
|
{
|
|
m_requiredInventoryItems = requiredInventoryItems;
|
|
m_requiredInventoryItemIDs.clear();
|
|
int numberOfRequiredInventoryItems = m_requiredInventoryItems.getSize();
|
|
auto inventoryItemPointers = m_requiredInventoryItems.getValues();
|
|
for (int index = 0; index < numberOfRequiredInventoryItems; index++)
|
|
{
|
|
m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
|
|
}
|
|
}
|
|
|
|
/*
|
|
Function: setLaborCost
|
|
Description: Sets the labor cost for the service.
|
|
Parameters:
|
|
- laborCost: New labor cost value.
|
|
Returns:
|
|
- void
|
|
*/
|
|
void Service::setLaborCost(double laborCost)
|
|
{
|
|
m_laborCost = laborCost;
|
|
}
|
|
|
|
/*
|
|
Function: setState
|
|
Description: Sets the state (ACTIVE/INACTIVE) of the service.
|
|
Parameters:
|
|
- status: New state value.
|
|
Returns:
|
|
- void
|
|
*/
|
|
void Service::setState(util::State status)
|
|
{
|
|
m_status = status;
|
|
}
|
|
|
|
/*
|
|
Function: getInventoryItemIDsAsString (static helper)
|
|
Description: Converts a vector of inventory item IDs into a single string separated by '|'.
|
|
Parameters:
|
|
- inventoryItemIds: const util::Vector<std::string>&, vector of inventory item IDs
|
|
Returns:
|
|
- std::string: Concatenated inventory item IDs string
|
|
*/
|
|
static std::string getInventoryItemIDsAsString(const util::Vector<std::string>& inventoryItemIds)
|
|
{
|
|
int numberOfInventoryItems = inventoryItemIds.getSize();
|
|
std::string inventoryItemIDs;
|
|
for (int index = 0; index < numberOfInventoryItems; index++)
|
|
{
|
|
inventoryItemIDs += inventoryItemIds[index];
|
|
if (index < numberOfInventoryItems - 1)
|
|
{
|
|
inventoryItemIDs += '|';
|
|
}
|
|
}
|
|
return inventoryItemIDs;
|
|
}
|
|
|
|
/*
|
|
Function: getInventoryItemIDsAsVector (static helper)
|
|
Description: Converts a string of inventory item IDs separated by '|' into a vector.
|
|
Parameters:
|
|
- inventoryItemIDsString: const std::string&, concatenated inventory item IDs string
|
|
Returns:
|
|
- util::Vector<std::string>: Vector of inventory item IDs
|
|
*/
|
|
static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string& inventoryItemIDsString)
|
|
{
|
|
util::Vector<std::string> inventoryItemIDs;
|
|
std::string inventoryItemID;
|
|
std::istringstream serializedInventoryItemIDs(inventoryItemIDsString);
|
|
while (getline(serializedInventoryItemIDs, inventoryItemID, '|'))
|
|
{
|
|
inventoryItemIDs.push_back(inventoryItemID);
|
|
}
|
|
return inventoryItemIDs;
|
|
}
|
|
|
|
/*
|
|
Function: serialize
|
|
Description: Serializes the service into a CSV-formatted string.
|
|
Parameters:
|
|
- None
|
|
Returns:
|
|
- std::string: Serialized service record
|
|
*/
|
|
std::string Service::serialize() const
|
|
{
|
|
std::ostringstream serializedService;
|
|
serializedService << m_id << ','
|
|
<< m_name << ','
|
|
<< getInventoryItemIDsAsString(m_requiredInventoryItemIDs) << ','
|
|
<< m_laborCost << ','
|
|
<< util::getStateString(m_status);
|
|
return serializedService.str();
|
|
}
|
|
|
|
/*
|
|
Function: deserialize
|
|
Description: Deserializes a CSV-formatted string into a Service object.
|
|
Parameters:
|
|
- record: const std::string&, serialized service record
|
|
Returns:
|
|
- Service*: Pointer to the deserialized Service object
|
|
Throws:
|
|
- std::runtime_error if labor cost parsing fails
|
|
*/
|
|
Service* Service::deserialize(const std::string& record)
|
|
{
|
|
std::string id, name;
|
|
std::string inventoryItemIDsString, laborCostString, statusString;
|
|
double laborCost;
|
|
std::istringstream serializedService(record);
|
|
getline(serializedService, id, ',');
|
|
getline(serializedService, name, ',');
|
|
getline(serializedService, inventoryItemIDsString, ',');
|
|
getline(serializedService, laborCostString, ',');
|
|
getline(serializedService, statusString, ',');
|
|
util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(inventoryItemIDsString);
|
|
try
|
|
{
|
|
laborCost = std::stod(laborCostString);
|
|
}
|
|
catch (...)
|
|
{
|
|
throw std::runtime_error("Invalid labor cost");
|
|
}
|
|
util::State status = util::getState(statusString);
|
|
return Factory::getObject<Service>(
|
|
id,
|
|
name,
|
|
inventoryItemIDs,
|
|
laborCost,
|
|
status
|
|
);
|
|
}
|
|
|
|
/*
|
|
Function: getHeaders
|
|
Description: Retrieves the CSV headers for service serialization.
|
|
Parameters:
|
|
- None
|
|
Returns:
|
|
- std::string: Header string ("ID,Name,InventoryIDs,LaborCost,Status")
|
|
*/
|
|
std::string Service::getHeaders()
|
|
{
|
|
return "ID,Name,InventoryIDs,LaborCost,Status";
|
|
} |