joelthomastrenser
b1b6125d88
Changes: - Added ensureDirectoryExists() helper using _mkdir() - Automatically create missing directories before file operations - Added FileHelper include in FileManager - Removed placeholder files/README.md Fixes #1793
119 lines
3.0 KiB
C++
119 lines
3.0 KiB
C++
/*
|
|
File: FileManager.h
|
|
Description: Declares and implements a generic FileManager template class for
|
|
loading and saving objects to and from files. Uses serialization
|
|
and deserialization methods defined in the object type T.
|
|
Provides persistence support for system entities such as Users,
|
|
Services, InventoryItems, etc.
|
|
Author: Trenser
|
|
Date: 22-May-2026
|
|
*/
|
|
|
|
#pragma once
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <fstream>
|
|
#include "Vector.h"
|
|
#include "Map.h"
|
|
#include "FileHelper.h"
|
|
|
|
namespace util
|
|
{
|
|
template <typename T> using objects = util::Map<std::string, T*>;
|
|
|
|
template <typename T>
|
|
class FileManager
|
|
{
|
|
private:
|
|
std::string m_filePath;
|
|
public:
|
|
FileManager() : m_filePath("") {}
|
|
FileManager(const std::string& filePath) : m_filePath(filePath) {}
|
|
objects<T> load();
|
|
void save(const objects<T>&);
|
|
};
|
|
|
|
/*
|
|
Function: load
|
|
Description: Loads records from the file into a map of objects.
|
|
Skips the header line, deserializes each record into an object of type T,
|
|
and stores them in a map keyed by object ID.
|
|
Parameters:
|
|
- None
|
|
Returns:
|
|
- util::Map<std::string, T*> containing deserialized objects
|
|
Throws:
|
|
- std::runtime_error if deserialization fails for any record
|
|
*/
|
|
template <typename T>
|
|
objects<T> FileManager<T>::load()
|
|
{
|
|
objects<T> records;
|
|
std::ifstream file(m_filePath);
|
|
if (!file.is_open())
|
|
{
|
|
ensureDirectoryExists(m_filePath);
|
|
std::ofstream newFile(m_filePath);
|
|
newFile.close();
|
|
file.open(m_filePath);
|
|
}
|
|
util::Vector<std::string> lines;
|
|
std::string line;
|
|
while (std::getline(file, line))
|
|
{
|
|
lines.push_back(line);
|
|
}
|
|
int numberOfLines = lines.getSize();
|
|
bool isHeader = true;
|
|
for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
|
|
{
|
|
const auto& record = lines[lineIndex];
|
|
if (isHeader)
|
|
{
|
|
isHeader = false;
|
|
continue;
|
|
}
|
|
auto object = T::deserialize(record);
|
|
if (!object)
|
|
{
|
|
throw std::runtime_error("Failed to deserialize record");
|
|
}
|
|
records[object->getId()] = object;
|
|
}
|
|
return records;
|
|
}
|
|
|
|
/*
|
|
Function: save
|
|
Description: Saves records to the file. Serializes each object of type T into a string,
|
|
writes a header line, and then writes all serialized records to the file.
|
|
Parameters:
|
|
- records: const util::Map<std::string, T*>&, map of objects to save
|
|
Returns:
|
|
- void
|
|
Throws:
|
|
- std::runtime_error if the file cannot be opened for writing
|
|
*/
|
|
template <typename T>
|
|
void FileManager<T>::save(const objects<T>& records)
|
|
{
|
|
util::Vector<std::string> lines;
|
|
lines.push_back(T::getHeaders());
|
|
int numberOfRecords = records.getSize();
|
|
for (int recordIndex = 0; recordIndex < numberOfRecords; recordIndex++)
|
|
{
|
|
const auto& record = records.getValueAt(recordIndex);
|
|
lines.push_back(record->serialize());
|
|
}
|
|
std::ofstream file(m_filePath, std::ios::trunc);
|
|
if (!file.is_open())
|
|
{
|
|
throw std::runtime_error("Failed to open file " + m_filePath);
|
|
}
|
|
int numberOfLines = lines.getSize();
|
|
for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
|
|
{
|
|
file << lines[lineIndex] << '\n';
|
|
}
|
|
}
|
|
} |