Jbrass/epr24pr5-ojanssen2
1
0
Fork 0
forked from University/epr24pr5-ojanssen2
Code Pull requests Activity

Doku Manger. Remove Write Methods

Browse source
This commit is contained in:
jbrass 2025-02-10 14:57:47 +01:00
parent ca572b6fb5
commit 9d2de95332
3 changed files with 143 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

179
Manager.cpp
View file

@ -1,19 +1,16 @@
#include "Manager.h"
#include "Error.h"
#include <fstream>
#include "DataType.h"
#include "Error.h"
using err::Error;
using util::DataType;
namespace util
{
Manager::Manager(): users({}), tasks({}), assignments({}), user_id_index(0), task_id_index(0), filename("tasks")
{
//Open File
namespace util {
Manager::Manager() : users({}), tasks({}), assignments({}), user_id_index(0), task_id_index(0), filename("tasks") {
// Open File
ifstream in = ifstream(this->filename, ios_base::in);
if (!in)
{
if (!in) {
this->save();
in.clear();
in.open(this->filename, ios_base::in);
@ -24,12 +21,10 @@ namespace util
DataType current_type = DataType::INIT;
string d; // dump
string line, section;
//Parse all Lines until EOF
while (getline(in, line))
{
// Parse all Lines until EOF
while (getline(in, line)) {
// Check if the line starts with '['
if (!line.empty() && line[0] == '[')
{
if (!line.empty() && line[0] == '[') {
if (line == "[tasks]")
current_type = DataType::TASK;
else if (line == "[users]")
@ -40,158 +35,134 @@ namespace util
throw Error(602, "Datei hat ein unbekanntes Format.");
continue;
}
//Lehre Zeilen überspringen.
// Lehre Zeilen überspringen.
if (line.empty())
continue;
//Speichern im Buffer
// Speichern im Buffer
buffer[current_type].push_back(line);
} //Data is parsed
} // Data is parsed
in.close();
// Reihenfolge der Verabeitung
vector<DataType> sections = { DataType::USER, DataType::TASK, DataType::ASSIGNMENT };
for (DataType type : sections)
{
vector<DataType> sections = {DataType::USER, DataType::TASK, DataType::ASSIGNMENT};
for (DataType type: sections) {
// Keine Data -> Continue
if (buffer.find(type) == buffer.end())
continue;
const vector<string>& lines = buffer[type];
//Iteriere über die Gebufferten Strings.
for (const string& buffered_line : lines)
{
const vector<string> &lines = buffer[type];
// Iteriere über die Gebufferten Strings.
for (const string &buffered_line: lines) {
stringstream string_stream(buffered_line);
switch (type)
{
case DataType::TASK:
{
switch (type) {
case DataType::TASK: {
Task task;
string_stream >> task;
this->tasks[task.get_id()] = new Task(task);
}
break;
case DataType::USER:
{
} break;
case DataType::USER: {
User user;
string_stream >> user;
this->users[user.get_id()] = new User(user);
}
break;
case DataType::ASSIGNMENT:
{
} break;
case DataType::ASSIGNMENT: {
Assignment assignment;
string_stream >> assignment;
this->assignments.push_back(new Assignment(assignment));
}
break;
default:
break;
} break;
default:
break;
}
}
}
this->update_indexes();
}
void Manager::update_user_id_index()
{
void Manager::update_user_id_index() {
int i = 0;
for (const auto& user_pair : this->users)
for (const auto &user_pair: this->users)
if (user_pair.second && user_pair.second->get_id() >= i)
i = user_pair.second->get_id() + 1;
this->user_id_index = i;
}
void Manager::update_task_id_index()
{
void Manager::update_task_id_index() {
int i = 0;
for (const auto& task_pair : this->tasks)
for (const auto &task_pair: this->tasks)
if (task_pair.second && task_pair.second->get_id() >= i)
i = task_pair.second->get_id() + 1;
this->task_id_index = i;
}
void Manager::update_indexes()
{
void Manager::update_indexes() {
this->update_user_id_index();
this->update_task_id_index();
}
int Manager::get_user_id()
{
int Manager::get_user_id() {
const int value = this->user_id_index;
++this->user_id_index;
return value;
}
int Manager::get_task_id()
{
int Manager::get_task_id() {
const int value = this->task_id_index;
++this->task_id_index;
return value;
}
Manager* Manager::INSTANCE = nullptr;
Manager *Manager::INSTANCE = nullptr;
Manager* Manager::get_instance()
{
Manager *Manager::get_instance() {
if (INSTANCE == nullptr)
INSTANCE = new Manager();
return INSTANCE;
}
vector<User*> Manager::get_users() const
{
vector<User*> user_vector;
for (const auto& pair : this->users)
vector<User *> Manager::get_users() const {
vector<User *> user_vector;
for (const auto &pair: this->users)
if (pair.second) // Ensure it's not a nullptr
user_vector.push_back(pair.second);
return user_vector;
}
vector<Task*> Manager::get_tasks() const
{
vector<Task*> task_vector;
for (const auto& pair : this->tasks)
vector<Task *> Manager::get_tasks() const {
vector<Task *> task_vector;
for (const auto &pair: this->tasks)
if (pair.second) // Ensure it's not a nullptr
task_vector.push_back(pair.second);
return task_vector;
}
vector<Assignment*> Manager::get_assignments()
{
return this->assignments;
}
vector<Assignment *> Manager::get_assignments() { return this->assignments; }
User* Manager::get_user(const int id)
{
User *Manager::get_user(const int id) {
if (this->users.count(id) == 0)
return nullptr;
return this->users[id];
}
Task* Manager::get_task(const int id)
{
Task *Manager::get_task(const int id) {
if (this->tasks.count(id) == 0)
return nullptr;
return this->tasks[id];
}
Vector<Assignment*> Manager::get_assignments_for_user(const int user_id)
{
Vector<Assignment*> user_assignments;
Vector<Assignment *> Manager::get_assignments_for_user(const int user_id) {
Vector<Assignment *> user_assignments;
if (this->get_user(user_id) == nullptr)
throw Error(401, "Eine solche BenutzerIn existiert nicht.");
for (Assignment* as : this->assignments)
for (Assignment *as: this->assignments)
if (as->get_user_id() == user_id)
user_assignments.push_back(as);
return user_assignments;
}
Vector<Assignment*> Manager::get_assignments_for_task(const int task_id)
{
Vector<Assignment*> task_assignments;
Vector<Assignment *> Manager::get_assignments_for_task(const int task_id) {
Vector<Assignment *> task_assignments;
if (this->get_task(task_id) == nullptr)
throw Error(401, "Eine solche BenutzerIn existiert nicht.");
for (Assignment* as : this->assignments)
for (Assignment *as: this->assignments)
if (as->get_task_id() == task_id)
task_assignments.push_back(as);
return task_assignments;
@ -199,29 +170,26 @@ namespace util
bool Manager::assignment_exists(int user_id, int task_id) {
for ( Assignment* as : this->assignments)
for (Assignment *as: this->assignments)
if (as->get_user_id() == user_id && as->get_task_id() == task_id)
return true;
return false;
}
void Manager::add_user(User* user)
{
void Manager::add_user(User *user) {
if (this->users.count(user->get_id()) == 1)
return;
this->users[user->get_id()] = user;
}
void Manager::add_task(Task* task)
{
void Manager::add_task(Task *task) {
if (this->tasks.count(task->get_id()) == 1)
return;
this->tasks[task->get_id()] = task;
}
void Manager::add_assignment(Assignment* as)
{
void Manager::add_assignment(Assignment *as) {
if (this->get_user(as->get_user_id()) == nullptr)
throw Error(401, "Eine solche BenutzerIn existiert nicht.");
@ -231,25 +199,24 @@ namespace util
this->assignments.push_back(as);
}
void Manager::del_user(const int id)
{
void Manager::del_user(const int id) {
if (this->users.count(id) == 0)
throw Error(401, "Eine solche BenutzerIn existiert nicht.");
//Assigment
// Assigment
if (!this->get_assignments_for_user(id).empty()) {
throw Error(201, "Benutzer kann nicht gelöscht werden.");
}
this->users.erase(id);
}
void Manager::del_task(const int id)
{
void Manager::del_task(const int id) {
if (this->tasks.count(id) == 0)
throw Error(402, "Eine solche Aufgabe existiert nicht.");
if (!this->get_assignments_for_task(id).empty()) {
throw Error(202, "Aufgabe kann nicht gelöscht werden.");
}
//TODO: Zudem kann eine Aufgabe nur gelöscht werden, wenn Sie nicht Nachfolgerin einer anderen Aufgabe ist -> Ensure its no Child
// TODO: Zudem kann eine Aufgabe nur gelöscht werden, wenn Sie nicht Nachfolgerin einer anderen Aufgabe ist ->
// Ensure its no Child
/*for (Task* task : this->get_tasks()) {
for (int child_id : task->get_children()) {
if (id == child_id) {
@ -257,20 +224,19 @@ namespace util
}
}
}*/
if (! this->get_task(id)->is_active()) {
if (!this->get_task(id)->is_active()) {
throw Error(202, "Aufgabe kann nicht gelöscht werden.");
}
this->tasks.erase(id);
}
void Manager::del_assignment(Assignment& as)
{
void Manager::del_assignment(Assignment &as) {
if (!this->assignment_exists(as.get_user_id(), as.get_task_id()))
throw Error(301, "Eine solche Zuordnung existiert nicht.");
int assignment_nr = 0;
for (int i = 0; i < this->assignments.size(); ++i) {
if (this->assignments[i]->get_user_id() == as.get_user_id() && this->assignments[i]->get_task_id() == as.get_task_id()) {
if (this->assignments[i]->get_user_id() == as.get_user_id() &&
this->assignments[i]->get_task_id() == as.get_task_id()) {
assignment_nr = i;
break;
}
@ -278,27 +244,28 @@ namespace util
this->assignments.erase(this->assignments.begin() + assignment_nr);
};
void Manager::save()
{
void Manager::save() {
ofstream out = ofstream(this->filename, ios_base::trunc);
if (!out)
throw Error(603, "Datei kann nicht geschrieben werden.");
out << "[tasks]\n";
for (const auto& task_pair : this->tasks)
for (const auto &task_pair: this->tasks)
if (task_pair.second)
task_pair.second->write(out);
// task_pair.second->write(out);
cout << task_pair.second;
out << "\n[users]\n";
for (const auto& user_pair : this->users)
for (const auto &user_pair: this->users)
if (user_pair.second)
user_pair.second->write(out);
// user_pair.second->write(out);
cout << user_pair.second;
out << "\n[assignments]\n";
for (Assignment* assignment : this->assignments)
for (Assignment *assignment: this->assignments)
if (assignment)
assignment->write(out);
// assignment->write(out);
cout << assignment;
out.close();
}
} // util
} // namespace util

70
Manager.h
View file

@ -12,49 +12,117 @@ using models::Assignment;
namespace util
{
/// Verwalter von Benutzern, Aufgaben und deren Zuordnungen.
class Manager
{
private:
//Singelton Instanz des Managers
static Manager* INSTANCE;
//Container für Zeiger auf alle User anhand der Id
map<int, User*> users;
//Container für Zeiger auf alle Task anhand der Id
map<int, Task*> tasks;
/// Speichert Zuordnungen von Benutzern zu Aufgaben.
vector<Assignment*> assignments;
//Nächste freie User Id
int user_id_index;
//Nächste frei Task Id
int task_id_index;
//Dateiname für den persistenten Speicher
string filename;
/// Erstellt eine Instanz des Managers und lädt vorhandene Daten.
Manager();
/// Aktualisiert die Benutzer-ID.
void update_user_id_index();
/// Aktualisiert die Aufgaben-ID.
void update_task_id_index();
public:
Manager(const Manager&) = delete;
Manager& operator=(const Manager&) = delete;
/// Holt die Singleton-Instanz des Managers.
/// @return Ein Zeiger auf die Instanz.
static Manager* get_instance();
/// Speichert die aktuellen Daten in einer Datei.
void save();
/// Aktualisiert die Benutzer- und Aufgaben-IDs.
void update_indexes();
/// Holt eine eindeutige Benutzer-ID.
/// @return Eine neue Benutzer-ID.
int get_user_id();
/// Holt eine eindeutige Aufgaben-ID.
/// @return Eine neue Aufgaben-ID.
int get_task_id();
/// Holt eine Liste aller Benutzer.
/// @return Ein Vektor von Benutzerzeigern.
vector<User*> get_users() const;
/// Holt eine Liste aller Aufgaben.
/// @return Ein Vektor von Aufgabenzeigern.
vector<Task*> get_tasks() const;
/// Holt eine Liste aller Zuordnungen.
/// @return Ein Vektor von Zuordnungen.
vector<Assignment*> get_assignments();
/// Holt einen Benutzer anhand der ID.
/// @param id Die Benutzer-ID.
/// @return Ein Zeiger auf den Benutzer oder nullptr.
User* get_user(int id);
/// Holt eine Aufgabe anhand der ID.
/// @param id Die Aufgaben-ID.
/// @return Ein Zeiger auf die Aufgabe oder nullptr.
Task* get_task(int id);
/// Holt alle Zuordnungen für einen Benutzer.
/// @param user_id Die Benutzer-ID.
/// @return Ein Vektor von Zuordnungen.
vector<Assignment *> get_assignments_for_user(int user_id);
/// Holt alle Zuordnungen für eine Aufgabe.
/// @param task_id Die Aufgaben-ID.
/// @return Ein Vektor von Zuordnungen.
vector<Assignment *> get_assignments_for_task(int task_id);
/// Prüft, ob eine Zuordnung existiert.
/// @param user_id Die Benutzer-ID.
/// @param task_id Die Aufgaben-ID.
/// @return Wahr, falls die Zuordnung existiert.
bool assignment_exists(int user_id, int task_id);
/// Fügt einen neuen Benutzer hinzu.
/// @param user Ein Zeiger auf den Benutzer.
void add_user(User* user);
/// Fügt eine neue Aufgabe hinzu.
/// @param task Ein Zeiger auf die Aufgabe.
void add_task(Task* task);
/// Fügt eine neue Zuordnung hinzu.
/// @param as Ein Zeiger auf die Zuordnung.
void add_assignment(Assignment* as);
/// Löscht einen Benutzer anhand der ID.
/// @param id Die Benutzer-ID.
void del_user(int id);
/// Löscht eine Aufgabe anhand der ID.
/// @param id Die Aufgaben-ID.
void del_task(int id);
/// Löscht eine Zuordnung.
/// @param as Die Zuordnung.
void del_assignment(Assignment& as);
};
} // util

1
main.cpp
View file

@ -35,6 +35,7 @@ const vector<SubCommand*> handlers = {
int main(int argc, char** argv)
{
//TODO:: THis needs to be removed?
if (argc < 2)
{
cout << "There are not enough args!\n";