feat: finished implementing stubs in Manager

fix: fixed initial problems with impl

ActiveCommand.cpp

@@ -12,7 +12,7 @@ namespace commands
     {
     }
 
-    void ActiveCommand::run(int argc, stringstream& args)
+    void ActiveCommand::run(stringstream& args)
     {
         Manager& mgr = Manager::get_instance();
         int user_id;

ActiveCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class ActiveCommand : public SubCommand {
     public:
         ActiveCommand();
-        void run(int argc, stringstream& args) override;
+        void run(stringstream& args) override;
     };
 
 } // commands

AddCommand.cpp

@@ -14,7 +14,7 @@ namespace commands
     {
     }
 
-    void AddCommand::run(int argc, stringstream& args)
+    void AddCommand::run(stringstream& args)
     {
         const string data_type = Util::read_string(args);
         Manager& mgr = Manager::get_instance();

AddCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class AddCommand: public SubCommand {
         public:
             AddCommand();
-            void run(int argc, stringstream& args) override;
+            void run(stringstream& args) override;
     };
 }
 #endif // ADDCOMMAND_H

AssignCommand.cpp

@@ -12,7 +12,7 @@ namespace commands
     {
     }
 
-    void AssignCommand::run(int argc, stringstream& args)
+    void AssignCommand::run(stringstream& args)
     {
         Manager& mgr = Manager::get_instance();
         int user_id, task_id;

AssignCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class AssignCommand : public SubCommand {
     public:
         AssignCommand();
-        void run(int argc, stringstream& args) override;
+        void run(stringstream& args) override;
     };
 
 } // commands

DataType.h

@@ -8,7 +8,7 @@ namespace util {
         INIT,
         USER,
         TASK,
-        USERTASKINDEX
+        ASSIGNMENT
     };
 } // util
 

DelCommand.cpp

@@ -12,7 +12,7 @@ namespace commands
     {
     }
 
-    void DelCommand::run(int argc, stringstream& args)
+    void DelCommand::run(stringstream& args)
     {
         Manager& mgr = Manager::get_instance();
         const string data_type = Util::read_string(args);

DelCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class DelCommand : public SubCommand {
     public:
         DelCommand();
-        void run(int argc, stringstream& args) override;
+        void run(stringstream& args) override;
     };
 
 } // commands

HelpCommand.cpp

@@ -3,7 +3,7 @@
 namespace commands {
     HelpCommand::HelpCommand(): SubCommand("help", 100, false) {}
 
-    void HelpCommand::run(int argc, stringstream& args) {
+    void HelpCommand::run(stringstream& args) {
         cout << "Projekt 5\n";
         cout << "epr24pr5-ojanssen2 <add/delete/list/show/assign/unassign/active/help>\n";
     }

HelpCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class HelpCommand: public SubCommand {
         public:
             HelpCommand();
-            void run(int argc, stringstream& args) override;
+            void run(stringstream& args) override;
     };
 } // commands
 #endif // HELPCOMMAND_H

ListCommand.cpp

@@ -15,18 +15,18 @@ namespace commands
     {
     }
 
-    void ListCommand::run(int argc, stringstream& args)
+    void ListCommand::run(stringstream& args)
     {
         Manager& mgr = Manager::get_instance();
         const string data_type = Util::read_string(args);
         if (data_type == "user")
-            for (User* u : mgr.get_users())
+            for (const User* u : mgr.get_users())
                 cout << *u;
         else if (data_type == "task")
-            for (Task* t : mgr.get_tasks())
+            for (const Task* t : mgr.get_tasks())
                 cout << *t;
         else if (data_type == "assignment")
-            for (Assignment* a : mgr.get_assignments())
+            for (const Assignment* a : mgr.get_assignments())
                 cout << *a;
         else
             throw Error(101, "Befehl ist unbekannt.");

ListCommand.h

@@ -8,7 +8,7 @@ namespace commands {
 class ListCommand : public SubCommand{
 public:
     ListCommand();
-    void run(int argc, stringstream& args) override;
+    void run(stringstream& args) override;
 };
 
 } // commands

Manager.cpp

@@ -36,7 +36,7 @@ namespace util
                 else if (line == "[users]")
                     current_type = DataType::USER;
                 else if (line == "[assignments]")
-                    current_type = DataType::USERTASKINDEX;
+                    current_type = DataType::ASSIGNMENT;
                 else
                     throw Error(602, "Datei hat ein unbekanntes Format.");
                 continue;
@@ -50,35 +50,37 @@ namespace util
         in.close();
 
         // Reihenfolge der Verabeitung
-        vector<DataType> sections = {DataType::USER, DataType::TASK, DataType::USERTASKINDEX};
+        vector<DataType> sections = { DataType::USER, DataType::TASK, DataType::ASSIGNMENT };
         for (DataType type : sections)
         {
             // Keine Data -> Continue
-            if (buffer.find(type) == buffer.end()) continue;
+            if (buffer.find(type) == buffer.end())
+                continue;
             const vector<string>& lines = buffer[type];
             //Iteriere über die Gebufferten Strings.
-            for (const string& bufferd_line : lines)
+            for (const string& buffered_line : lines)
             {
+                stringstream string_stream(buffered_line);
                 switch (type)
                 {
                 case DataType::TASK:
                     {
                         Task task;
-                        in >> task;
+                        string_stream >> task;
                         this->tasks[task.get_id()] = new Task(task);
                     }
                     break;
                 case DataType::USER:
                     {
                         User user;
-                        in >> user;
+                        string_stream >> user;
                         this->users[user.get_id()] = new User(user);
                     }
                     break;
-                case DataType::USERTASKINDEX:
+                case DataType::ASSIGNMENT:
                     {
                         Assignment assignment;
-                        in >> assignment;
+                        string_stream >> assignment;
                         this->assignments.push_back(new Assignment(assignment));
                     }
                     break;
@@ -136,52 +138,141 @@ namespace util
             INSTANCE = new Manager();
         return *INSTANCE;
     }
-    vector<User*> const Manager::get_users() {
-        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<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)
+            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;
+    }
+
+    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)
+    {
+        if (this->tasks.count(id) == 0)
+            return nullptr;
+        return this->tasks[id];
+    }
+
+    Vector<Assignment*> Manager::get_assignments_for_user(const int& id)
+    {
+        Vector<Assignment*> user_assignments;
+        if (this->get_user(id) == nullptr)
+            throw Error(401, "Eine solche BenutzerIn existiert nicht.");
+        for (Assignment* as : this->assignments)
+            if (as->get_user_id() == id)
+                user_assignments.push_back(as);
+        return user_assignments;
+    }
+
+    bool Manager::assignment_exists(const int& user_id, const int& task_id)
+    {
+        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)
+    {
+        if (this->users.count(user->get_id()) == 1)
+            return;
+        this->users[user->get_id()] = user;
+    }
+
+
+    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)
+    {
+        if (this->get_user(as->get_user_id()) == nullptr)
+            throw Error(401, "Eine solche BenutzerIn existiert nicht.");
+
+        if (this->get_task(as->get_task_id()) == nullptr)
+            throw Error(402, "Eine solche Aufgabe existiert nicht.");
+
+        this->assignments.push_back(as);
+    }
+
+    void Manager::del_user(const int& id)
+    {
+        if (this->users.count(id) == 0)
+            throw Error(401, "Eine solche BenutzerIn existiert nicht.");
+
+        this->users.erase(id);
+    }
+
+    void Manager::del_task(const int& id)
+    {
+        if (this->tasks.count(id) == 0)
+            throw Error(402, "Eine solche Aufgabe existiert nicht.");
+
+        this->tasks.erase(id);
+    }
+
+    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() - 1; ++i) {
+            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;
+            }
+        }
+        this->assignments.erase(this->assignments.begin() + assignment_nr);
     };
-    vector<Task*> get_tasks();
+
-    vector<Assignment*> get_assignments();
     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->users)
+        for (const auto& task_pair : this->tasks)
-        {
-            //Nullpointer Check
             if (task_pair.second)
-            {
                 task_pair.second->write(out);
-            }
+
-        }
         out << "\n[users]\n";
         for (const auto& user_pair : this->users)
-        {
-            //Nullpointer Check
             if (user_pair.second)
-            {
                 user_pair.second->write(out);
-            }
-        }
 
         out << "\n[assignments]\n";
         for (Assignment* assignment : this->assignments)
-        {
-            //Nullpointer Check
             if (assignment)
-            {
                 assignment->write(out);
-            }
+
-        }
         out.close();
     }
-
 } // util

Manager.h

@@ -37,8 +37,8 @@ namespace util
         int get_user_id();
         int get_task_id();
 
-        vector<User*> get_users();
+        vector<User*> get_users() const;
-        vector<Task*> get_tasks();
+        vector<Task*> get_tasks() const;
         vector<Assignment*> get_assignments();
 
         User* get_user(const int& id);
@@ -46,13 +46,13 @@ namespace util
         vector<Assignment*> get_assignments_for_user(const int& id);
         bool assignment_exists(const int& user_id, const int& task_id);
 
-        void add_user(const User* user);
+        void add_user(User* user);
-        void add_task(const Task* task);
+        void add_task(Task* task);
-        void add_assignment(const Assignment* as);
+        void add_assignment(Assignment* as);
 
         void del_user(const int& id);
         void del_task(const int& id);
-        void del_assignment(const Assignment& as);
+        void del_assignment(Assignment& as);
     };
 } // util
 #endif // ENVIRONMENT_H

ShowCommand.cpp

@@ -16,7 +16,7 @@ namespace commands
     {
     }
 
-    void ShowCommand::run(int argc, stringstream& args)
+    void ShowCommand::run(stringstream& args)
     {
         Manager& mgr = Manager::get_instance();
         const string data_type = Util::read_string(args);

ShowCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class ShowCommand  : public SubCommand {
     public:
         ShowCommand();
-        void run(int argc, stringstream& args) override;
+        void run(stringstream& args) override;
     };
 
 } // commands

SubCommand.cpp

@@ -4,7 +4,7 @@
 namespace commands {
     SubCommand::SubCommand(const string& name, const int& return_value, const bool show_result): name(name), return_value(return_value), show_result(show_result) {}
 
-    void SubCommand::run(int argc, stringstream& args) {
+    void SubCommand::run(stringstream& args) {
         cout << "Not impl!\n";
     }
 

SubCommand.h

@@ -19,7 +19,7 @@ namespace commands
         string get_name();
         int get_value() const;
         bool should_display_result() const;
-        virtual void run(int argc, stringstream& args);
+        virtual void run(stringstream& args);
     };
 } // commands
 

UnassignCommand.cpp

@@ -11,7 +11,7 @@ namespace commands
     {
     }
 
-    void UnassignCommand::run(int argc, stringstream& args)
+    void UnassignCommand::run(stringstream& args)
     {
         Manager& mgr = Manager::get_instance();
         int user_id, task_id;
@@ -26,7 +26,8 @@ namespace commands
             throw Error(401, "Eine solche Zuordnung existiert nicht.");
         if (!mgr.assignment_exists(user_id, task_id))
             throw Error(302, "Eine solche Zuordnung existiert bereits.");
-        mgr.del_assignment({user_id, task_id});
+        Assignment as = {user_id, task_id};
+        mgr.del_assignment(as);
         mgr.save();
     }
 } // commands

UnassignCommand.h

@@ -8,7 +8,7 @@ namespace commands {
     class UnassignCommand : public SubCommand {
     public:
         UnassignCommand();
-        void run(int argc, stringstream& args) override;
+        void run(stringstream& args) override;
     };
 
 } // commands

main.cpp

@@ -48,15 +48,18 @@ int main(int argc, char** argv)
         {
             if (sc->get_name() == command)
             {
-                sc->run(argc, parameter);
+                sc->run(parameter);
-                return 0;
+                if (sc->should_display_result())
+                    cout << "100: Alles erfolgreich\n";
+                return sc->get_value();
             }
         }
     }
     catch (Error& e)
     {
         cout << e.get_nr() << ": " << e.what() << "\n";
+        return e.get_nr();
     }
     cout << "101: Befehl ist unbekannt.\n";
-    return 0;
+    return 101;
 }