Init

P1/ADS_P1_1_Ringpuffer/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(P1_1_Ringpuffer)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_executable(P1_1_Ringpuffer main.cpp Ring.cpp RingNode.cpp RingTest.cpp)

P1/ADS_P1_1_Ringpuffer/Ring.cpp

@@ -0,0 +1,107 @@
+/*************************************************
+* ADS Praktikum 1.1
+* Ring.cpp
+* Erweiterung um Hilfsfunktionen gestattet.
+*************************************************/
+// Ring .cpp
+#include "Ring.h"
+#include <iostream>
+
+Ring::Ring() {
+    m_anker = nullptr;
+    m_countNodes = 0;
+};
+
+void Ring::addNewNode(std::string Beschreibung, std::string Data) {
+    RingNode* newNode = new RingNode(0, Beschreibung, Data);
+
+    // Fall 1 Ring ist leer
+    if (m_countNodes == 0) {
+        m_anker = newNode;
+        newNode->setNext(m_anker);
+        m_anker->setNext(newNode);
+        m_countNodes++;
+    }
+
+    // Fall 2 Ring ist nut teilweise voll
+    else if (m_countNodes != 6) {
+        RingNode* ptr = m_anker->getNext();
+
+        newNode->setNext(m_anker->getNext());
+        m_anker->setNext(newNode);
+        m_anker = newNode;
+        m_countNodes++;
+
+        if (m_countNodes == 1)
+            m_anker->setOldAge(m_anker->getOldAge() + 1);
+        else {
+            while (ptr != m_anker) {
+                ptr->setOldAge(ptr->getOldAge() + 1);
+                ptr = ptr->getNext();
+            }
+        }
+    }
+
+    // Fall 3 Ring ist voll
+    else if (m_countNodes == 6) {
+        RingNode* nodeAge5 = m_anker->getNext();
+        newNode->setNext(nodeAge5->getNext());
+        m_anker->setNext(newNode);
+        delete nodeAge5;
+        m_anker = newNode;
+
+        RingNode* ptr = m_anker->getNext();
+        while (ptr != m_anker) {
+            ptr->setOldAge(ptr->getOldAge() + 1);
+            ptr = ptr->getNext();
+        }
+    }
+};
+
+bool Ring::search(std::string Data) {
+    if (m_anker != nullptr) {
+        // Fängt beim letzten/ältesten Knoten in der Liste an
+        RingNode* ptr = m_anker->getNext();
+
+        while (ptr->getNext() != m_anker->getNext() && ptr->getSymbolicData() != Data)
+            ptr = ptr->getNext();
+
+        if (ptr->getSymbolicData() == Data)
+            return true;
+        else
+            return false;
+    }
+    else return false;
+}
+
+void Ring::printNode(std::string Data) {
+    if (search(Data)) {
+        // Fangen beim ältesten Knoten an
+        RingNode* ptr = m_anker->getNext();
+
+        //       kein doppeltes Durchlaufen       und   Data stimmt nicht überein
+        while (ptr->getNext() != m_anker->getNext() && ptr->getSymbolicData() != Data)
+            ptr = ptr->getNext();
+
+        // die while Schleife wird abgebrochen werden, da Data übereinstimmt. Data muss vorhanden sein da if(search(data) == true)
+        std::cout << "+ Gefunden in Backup: ";
+        std::cout << "Alter " << ptr->getOldAge() << ", Beschreibung: " << ptr->getDescription() << ", Daten: " << ptr->getSymbolicData() << std::endl;
+    }
+    else
+        std::cout << "+ Datensatz konnte nicht gefunden werden." << std::endl;
+}
+
+void Ring::print() {
+    std::cout << std::endl;
+    // Zählt den Knoten der ausgegeben werden soll
+    for (int i = 0; i < m_countNodes; i++) {
+        RingNode* tempNode = m_anker;
+        // geht bis zu diesem
+        for (int j = 0; j < m_countNodes - i; j++) {
+            tempNode = tempNode->getNext();
+        }
+        std::cout << "Alter " << tempNode->getOldAge() << ", Beschreibung: " << tempNode->getDescription() << ", Daten: " << tempNode->getSymbolicData() << std::endl
+            << "-------------------------------" << std::endl;
+    }
+    std::cout << std::endl;
+};

P1/ADS_P1_1_Ringpuffer/Ring.h

@@ -0,0 +1,27 @@
+/*************************************************
+* ADS Praktikum 1.1
+* Ring.h
+* Erweiterung um Hilfsfunktionen gestattet.
+*************************************************/
+// Ring .h
+#pragma once
+#include<string>
+#include "catch.h"
+#include"RingNode.h"
+
+class Ring {
+private:
+	int m_countNodes;
+	RingNode* m_anker;
+	friend int getOldAge();
+public:
+	Ring();
+	void addNewNode(std::string Beschreibung, std::string Data);
+	bool search(std::string Data);
+	void printNode(std::string Data);
+	void print();
+	
+	// friend Funktionen müssen unangetastet bleiben! 
+	friend RingNode* get_anker(Ring& r);
+	friend int get_countNodes(Ring& r);
+};

P1/ADS_P1_1_Ringpuffer/RingNode.cpp

@@ -0,0 +1,41 @@
+/*************************************************
+* ADS Praktikum 1.1
+* RingNode.cpp
+* Erweiterung um Hilfsfunktionen gestattet.
+*************************************************/
+#include "RingNode.h"
+
+
+RingNode::RingNode(){};
+
+int RingNode::getOldAge() {
+    return m_oldAge;
+};
+
+void RingNode::setOldAge(int value) {
+    m_oldAge = value;
+};
+
+std::string RingNode::getDescription() {
+    return m_description;
+};
+
+void RingNode::setDescription(std::string value) {
+    m_description = value;
+};
+
+std::string RingNode::getSymbolicData() {
+    return m_symbolicData;
+};
+
+void RingNode::setSymbolicData(std::string value) {
+    m_symbolicData = value;
+};
+
+RingNode* RingNode::getNext() {
+    return m_next;
+};
+
+void RingNode::setNext(RingNode* node) {
+    m_next = node;
+};

P1/ADS_P1_1_Ringpuffer/RingNode.h

@@ -0,0 +1,27 @@
+/*************************************************
+* ADS Praktikum 1.1
+* RingNode.h
+* Erweiterung um Hilfsfunktionen gestattet.
+*************************************************/
+#pragma once
+#include <string>
+
+class RingNode {
+private:
+	int m_oldAge;
+	std::string m_description;
+	std::string m_symbolicData;
+	RingNode* m_next;
+
+public:
+	RingNode();
+	RingNode(int a, std::string d, std::string s) : m_oldAge { a }, m_description { d }, m_symbolicData { s }, m_next { nullptr } { };
+	int getOldAge();
+	void setOldAge(int);
+	std::string getDescription();
+	void setDescription(std::string);
+	std::string getSymbolicData();
+	void setSymbolicData(std::string);
+	RingNode* getNext();
+	void setNext(RingNode*);
+};

P1/ADS_P1_1_Ringpuffer/RingTest.cpp

@@ -0,0 +1,162 @@
+/*************************************************
+ * ADS Praktikum 1.1
+ * Unit-Testdatei
+ * Aenderungen fuers Praktikum untersagt!
+ *************************************************/
+#include "Ring.h"
+#include "RingNode.h"
+#include "catch.h"
+#include <string>
+
+using namespace std;
+
+// Friend-Methode fuer Testroutine
+RingNode* get_anker(Ring& r)
+{
+    return r.m_anker;
+}
+
+int get_countNodes(Ring& r)
+{
+    return r.m_countNodes;
+}
+
+TEST_CASE("Ring Testing", "[Ring]")
+{
+
+    Ring rloop;
+
+    SECTION("Hinzufuegen von Nodes und Suche - simple")
+    {
+
+        rloop.addNewNode("Alpha", "Data");
+        rloop.addNewNode("Beta", "Data");
+        rloop.addNewNode("Gamma", "Data");
+
+        REQUIRE(get_countNodes(rloop) == 3);
+
+        REQUIRE(rloop.search("Data") == true);
+        REQUIRE(rloop.search("FAIL") == false);
+        REQUIRE(rloop.search("Alpha") == false);
+        REQUIRE(rloop.search("Data") == true);
+    }
+
+    SECTION("Hinzufuegen von Nodes - Rotaionsgrenze")
+    {
+        rloop.addNewNode("Alpha", "Data1");
+        rloop.addNewNode("Beta", "Data2");
+        rloop.addNewNode("Gamma", "Data3");
+        rloop.addNewNode("Delta", "Data4");
+        rloop.addNewNode("Phi", "Data5");
+        rloop.addNewNode("Sept", "Data6");
+        rloop.addNewNode("Gamma", "Data7");
+        rloop.addNewNode("Gamma", "Data8");
+        rloop.addNewNode("Gamma", "Data9");
+
+        REQUIRE(get_countNodes(rloop) == 6);
+
+        REQUIRE(rloop.search("Data1") == false);
+        REQUIRE(rloop.search("Data2") == false);
+        REQUIRE(rloop.search("Data7") == true);
+        REQUIRE(rloop.search("Data5") == true);
+    }
+
+    SECTION("Hinzufuegen von Nodes - Rotaionsperformance")
+    {
+
+        for (int i = 0; i < 1024; i++)
+        {
+            string info = "Info" + to_string(i);
+            string data = "Data" + to_string(i);
+            rloop.addNewNode(info, data);
+        }
+
+        REQUIRE(get_countNodes(rloop) == 6);
+
+        REQUIRE(rloop.search("Data1") == false);
+        REQUIRE(rloop.search("Data2") == false);
+        REQUIRE(rloop.search("Data1020") == true);
+        REQUIRE(rloop.search("Data1023") == true);
+    }
+
+    SECTION("Ringarchitektur - Verkettungspruefung 1")
+    {
+
+        for (int i = 0; i < 3; i++)
+        {
+            string info = "Info" + to_string(i);
+            string data = "Data" + to_string(i);
+            rloop.addNewNode(info, data);
+        }
+
+        RingNode* ref = get_anker(rloop);
+        REQUIRE(get_countNodes(rloop) == 3);
+        REQUIRE(ref->getSymbolicData() == "Data2");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data0");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data1");
+        ref = ref->getNext();
+        REQUIRE(ref == get_anker(rloop));
+    }
+    SECTION("Ringarchitektur - Verkettungspruefung 2")
+    {
+
+        for (int i = 0; i < 10; i++)
+        {
+            string info = "Info" + to_string(i);
+            string data = "Data" + to_string(i);
+            rloop.addNewNode(info, data);
+        }
+
+        RingNode* ref = get_anker(rloop);
+        REQUIRE(get_countNodes(rloop) == 6);
+        REQUIRE(ref->getSymbolicData() == "Data9");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data4");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data5");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data6");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data7");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data8");
+        ref = ref->getNext();
+        REQUIRE(ref->getSymbolicData() == "Data9");
+        REQUIRE(ref == get_anker(rloop));
+
+        // Fail-Test:
+        // REQUIRE(get_anker(rloop)->getSymbolicData() == "Data4");
+    }
+}
+
+TEST_CASE("RingNode Testing", "[RingNode]")
+{
+
+    SECTION("Get/Setter von RingNode - simple")
+    {
+
+        RingNode* node = new RingNode(1, "Info", "Data");
+        REQUIRE(node->getOldAge() == 1);
+        REQUIRE(node->getDescription() == "Info");
+        REQUIRE(node->getSymbolicData() == "Data");
+        REQUIRE(node->getNext() == nullptr);
+
+        node->setOldAge(5);
+        REQUIRE(node->getOldAge() == 5);
+
+        node->setDescription("newInfo");
+        REQUIRE(node->getDescription() == "newInfo");
+
+        node->setSymbolicData("newData");
+        REQUIRE(node->getSymbolicData() == "newData");
+
+        RingNode* node2 = new RingNode(2, "Info2", "Data2");
+        node->setNext(node2);
+        REQUIRE(node->getNext() == node2);
+
+        delete node;
+        delete node2;
+    }
+}

P1/ADS_P1_1_Ringpuffer/main.cpp

@@ -0,0 +1,75 @@
+/*************************************************
+* ADS Praktikum 1.1
+* main.cpp
+*
+*************************************************/
+#define CATCH_CONFIG_RUNNER
+
+#include <iostream>
+#include <string>
+#include "Ring.h"
+#include "catch.h"
+
+using namespace std;
+
+void print_menu() {
+    cout << "====================================" << endl
+        << " SuperBackUp-Organizer over 9000, by. Son Goku" << endl
+        << "====================================" << endl
+        << "1) Backup anlegen" << endl
+        << "2) Backup suchen" << endl
+        << "3) Alle Backups ausgeben" << endl
+        << "4) Programm beenden" << endl
+        << "?> ";
+}
+
+int main() {
+    int result = Catch::Session().run();
+
+    Ring ring;
+
+    while (true) {
+        print_menu();
+
+        int engb;
+        cin >> engb;
+
+        switch (engb) {
+            case 1: {
+                cout << "+ Neuen Datensatz einfuegen" << endl
+                    << "Beschreibung ?> ";
+                string desc;
+                cin >> desc;
+                cout << "Daten ?> ";
+                string data;
+                cin >> data;
+                ring.addNewNode(desc, data);
+                cout << "+ Datensatz hinzugefuegt." << endl;
+                break;
+            }
+
+            case 2: {
+                cout << "+ Nach welchen Daten soll gesucht werden?" << endl
+                    << "?> ";
+                string to_find;
+                cin >> to_find;
+                ring.printNode(to_find);
+                break;
+            }
+
+            case 3:
+                ring.print();
+                break;
+
+            case 4:
+                return result;
+                
+            default:
+                cout << "Invalid selection!" << endl;
+        }
+    }
+
+
+    system("Pause");
+    return result;
+}