Adding new ring buffer code

EOOP/Various/ringBuffer2/ringbuffer2.cpp

@@ -0,0 +1,359 @@
+// Krzysztof Rudnicki, 307585, EADS 2
+#include <iostream>
+
+void print(const std::string s)
+{
+	std::cout << s << std::endl;
+}
+
+template<typename Key, typename Info>
+class Ring{
+private:
+	struct Node{
+		Key key;
+		Info info;
+		Node* next;
+		Node* prev;
+	};
+	Node* any;
+public:
+
+	class Iterator
+	{
+		private:
+			Node* pNode;
+		public:
+			Iterator() { pNode = nullptr; }
+			~Iterator() { pNode = nullptr; }
+			Iterator(Node* ptr) : pNode(ptr) {}
+			
+			bool operator!=(const Iterator& other) const
+			{
+				return pNode != other.pNode;
+			}
+
+			Iterator& operator++()
+			{
+				pNode = pNode -> next;
+				return *this;
+			}
+			
+			Iterator operator++(int)
+			{
+				Iterator it = *this;
+				pNode = pNode -> next;
+				return it;
+			}
+			
+				Iterator& operator--()
+			{
+				pNode = pNode -> prev;
+				return *this;
+			}
+			
+			Iterator operator--(int)
+			{
+				Iterator it = *this;
+				pNode = pNode -> prev;
+				return it;
+			}
+
+			Node& operator[](int index)
+			{
+				Node* indexedNode = pNode;
+				for(int i = 0; i < index; i++)
+				{
+					indexedNode = indexedNode -> next;
+				}
+				return *indexedNode;
+			}
+			
+			Node* operator->()
+			{
+				return pNode;
+			}
+			
+			Node& operator*()
+			{
+				return *pNode;
+			}
+			
+			bool operator==(const Iterator& other) const
+			{
+				return pNode == other.pNode;
+			}
+	};
+	
+	Ring();
+	~Ring();
+	void clearRing();
+	void print() const;
+	void addAtEnd(Key newKey, Info newInfo);
+	int size() const;
+	Iterator begin() const // I will treat "any" Node as a "begining" of a ring
+	{
+		return Iterator(any);
+	}
+	
+	Iterator end() const  // I will treat a Node just before "any" node as an "end" of a ring
+	{
+		if(any == nullptr) return nullptr;
+		return any -> prev;
+	}
+};
+
+template<typename Key, typename Info>
+Ring<Key, Info>::Ring()
+{
+	any = nullptr;
+}
+
+template<typename Key, typename Info>
+void Ring<Key, Info>::clearRing()
+{
+	if(any == nullptr) return;
+	Node* curr = any;
+	Node* temp = any;
+	do{
+		temp = curr;
+		curr = curr->next;
+		delete temp;
+	}while(curr != any);
+
+	delete any;
+}
+
+template<typename Key, typename Info>
+Ring<Key, Info>::~Ring()
+{
+	this -> clearRing();
+}
+
+template<typename Key, typename Info>
+void Ring<Key, Info>::print() const
+{
+	Node* curr = any;
+	do{
+		std::cout << curr -> key << "; " << curr->info << std::endl;
+		curr = curr->next;
+	}while (curr != any);
+}
+
+template<typename Key, typename Info>
+void Ring<Key, Info>::addAtEnd(Key newKey, Info newInfo)
+{
+	Node* newNode = new Node();
+	newNode -> key = newKey;
+	newNode -> info = newInfo;
+	if(any == nullptr)
+	{
+		any = newNode;
+		any -> next = any;
+		any -> prev = any;
+		return;
+	}
+	
+	if(any -> next == nullptr)
+	{
+		any -> next = newNode;
+		any -> prev = newNode;
+		newNode -> next = any;
+		newNode -> prev = any;
+		return;
+	}
+	
+	Node* curr = any;
+	while(curr -> next != any) curr = curr -> next;
+	any->prev = newNode;
+	curr->next = newNode;
+	newNode -> prev = curr;
+	newNode -> next = any;
+}
+
+template<typename Key, typename Info>
+int Ring<Key, Info>::size() const
+{
+	Node* curr = any;
+	int size = 0;
+	do{
+		size++;
+		curr = curr -> next;
+	}while (curr != any);
+	return size;
+}
+
+template <typename Key, typename Info>
+void printPair(const Key key, const Info info)
+{
+	std::cout << "Key: " << key << "; Info: " << info << std::endl;
+}
+
+bool testForEmpty()
+{
+	Ring<int, int> marcel;
+	Ring<int, int>::Iterator it = marcel.begin();
+	if(it != nullptr)
+	{
+		 print("testForEmpty");
+		return false;
+	}
+	return true;
+}
+
+bool testOneElement()
+{
+	Ring<int, int> marcel;
+	marcel.addAtEnd(1, 1);
+	Ring<int, int>::Iterator it = marcel.begin();
+	if(it -> key != 1 || it -> info != 1)
+	{
+		print("testForwardIncrementingOneElement");
+		return false;
+	}
+	return true;
+}
+
+bool testForwardIncrementing()
+{
+	Ring<int, int> marcel;
+	marcel.addAtEnd(1, 1);
+	marcel.addAtEnd(2, 2);
+	marcel.addAtEnd(3, 3);
+	marcel.addAtEnd(4, 4);
+	marcel.addAtEnd(5, 5);
+	int i = 0;
+	for( Ring<int, int>::Iterator it = marcel.begin();
+	it != marcel.end(); it++, i++)
+	{
+		if(it -> key != i + 1 || it -> info != i + 1)
+		{
+			print("testForwardIncrementingNormal");
+			return false;
+		}
+	}
+	if(marcel.end() -> key != 5 || marcel.end() -> info != 5)
+	{
+		print("testForwardIncrementingNormal");
+		return false;
+	}
+
+	return true;
+}
+
+bool testBackwardDecrementing()
+{
+	Ring<int, int> marcel;
+	marcel.addAtEnd(1, 1);
+	marcel.addAtEnd(2, 2);
+	marcel.addAtEnd(3, 3);
+	marcel.addAtEnd(4, 4);
+	marcel.addAtEnd(5, 5);
+	int i = 0;
+	for( Ring<int, int>::Iterator it = marcel.end();
+	it != marcel.begin(); it++, i++)
+	{
+		if(it -> key != 5 - i || it -> info != 5 - i)
+		{
+			print("testBackwardDecrementing");
+			return false;
+		}
+	}
+	if(marcel.begin() -> key != 1 || marcel.begin() -> info != 1)
+	{
+		print("testBackwardDecrementing");
+		return false;
+	}
+
+	return true;
+}
+
+bool testForwardSquareBracket()
+{
+	Ring<int, int> marcel;
+	marcel.addAtEnd(1, 1);
+	marcel.addAtEnd(2, 2);
+	marcel.addAtEnd(3, 3);
+	marcel.addAtEnd(4, 4);
+	marcel.addAtEnd(5, 5);
+	Ring<int, int>::Iterator it = marcel.begin();
+	for(int i = 0; i < marcel.size(); i++)
+	{
+		if(it[i].key != i + 1 || it[i].info != i + 1)
+		{
+			print("testForwardSquareBracket");
+			return false;
+		}
+	}
+	return true;
+}
+
+
+bool testBackwardSquareBracket()
+{
+	Ring<int, int> marcel;
+	marcel.addAtEnd(1, 1);
+	marcel.addAtEnd(2, 2);
+	marcel.addAtEnd(3, 3);
+	marcel.addAtEnd(4, 4);
+	marcel.addAtEnd(5, 5);
+	Ring<int, int>::Iterator it = marcel.end();
+	for(int i = marcel.size(); i > 0; i--)
+	{
+		if(it[i].key != i || it[i].info != i)
+		{
+			print("testBackwardSquareBracket");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool testSquareBracketRandomOverflow()
+{
+	Ring<int, int> marcel;
+	marcel.addAtEnd(1, 1);
+	marcel.addAtEnd(2, 2);
+	marcel.addAtEnd(3, 3);
+	marcel.addAtEnd(4, 4);
+	marcel.addAtEnd(5, 5);
+	Ring<int, int>::Iterator it = marcel.begin();
+	//Checking for some random places in ring:
+	if(it[2].key != 3) 
+	{
+		print("testSquareBracketRandomOverflow");
+		return false;
+	}
+	
+	if(it[4].key != 5) 
+	{
+		print("testSquareBracketRandomOverflow");
+		return false;
+	}
+	
+	if(it[0].key != 1) 
+	{
+		print("testSquareBracketRandomOverflow");
+		return false;
+	}
+	//Checking for overflow:
+	if(it[10].key != 1) 
+	{
+		print("testSquareBracketRandomOverflow");
+		return false;
+	}
+	return true;
+}
+
+bool tests()
+{
+	return testForEmpty()&&testOneElement()&&testForwardIncrementing()
+	&&testBackwardDecrementing()&&testForwardSquareBracket()&&testBackwardSquareBracket()
+	&&testSquareBracketRandomOverflow();
+}
+
+int main()
+{
+	std::cout << "Result of tests is: " << tests() << std::endl;
+	return 1;
+	
+}

EOOP/Various/ringBuffer2/ringbuffer3.cpp

@@ -0,0 +1,406 @@
+#include <iostream>
+
+using namespace std;
+
+template <typename Key, typename Info>
+class Ring
+{
+private:
+    struct Node
+    {
+        Key key;
+        Info info;
+        Node *prev;
+        Node *next;
+    };
+    Node *head;
+
+public:
+    class Iterator
+    {
+    private:
+        Node *ptr;
+        Node *headPtr;
+        Iterator(Node*);
+        friend class Ring<Key, Info>;
+    public:
+        Iterator();
+        Iterator(Ring);
+        Info getInfo();
+        Key getKey();
+        void printData(int);
+        Info operator*();
+        Iterator& operator++();//prefix
+        Iterator operator++(int);//postfix
+        Iterator& operator--();//prefix
+        Iterator operator--(int);//postfix
+        bool operator==(const Iterator&);
+        bool operator!=(const Iterator&);
+        bool isFirst();
+        bool isLast();
+    };
+
+    Ring();
+    ~Ring();
+    void insertAtBeginning(const Key& k, const Info& inf);
+    void insertAtEnd(const Key& k, const Info& inf);
+    void removeAtBeginning();
+    void removeAtEnd();
+    void clear();
+
+    void printContent();
+    void printContentReverse();
+
+    Iterator begin();
+    Iterator end();
+};
+
+//main function
+int main()
+{
+    //test 1 - printing
+
+    Ring<char, string> ring;
+
+    ring.insertAtEnd('a', "letter 1");
+    ring.insertAtEnd('b', "letter 2");
+    ring.insertAtEnd('c', "letter 3");
+    ring.insertAtEnd('d', "letter 4");
+    ring.insertAtEnd('e', "letter 5");
+
+    cout << "Normal print:" << endl;
+    ring.printContent();
+
+    Ring<char, string>::Iterator *ringIt = new Ring<char, string>::Iterator(ring);
+
+    cout << endl << "Iterator print:" << endl;
+    int number = 0;
+    while (ringIt->isLast() == false)
+    {
+        ringIt->printData(number);
+
+        number++;
+        ++ringIt;
+    }
+
+
+    return 0;
+}
+
+//------------------------------Ring functions
+
+template <typename Key, typename Info>
+Ring<Key, Info>::Ring()
+{
+    head = nullptr;
+}
+
+template <typename Key, typename Info>
+Ring<Key, Info>::~Ring()
+{
+    clear();
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::insertAtBeginning(const Key& k, const Info& inf)
+{
+    if (head == nullptr)
+    {
+        Node *newNode = new Node();
+        newNode->key = k;
+        newNode->info = inf;
+        newNode->next = newNode;
+        newNode->prev = newNode;
+
+        head = newNode;
+
+        return;
+    }
+
+    Node *last = head->prev;
+
+    Node *newNode = new Node();
+    newNode->key = k;
+    newNode->info = inf;
+    newNode->prev = last;
+    last->next = newNode;
+
+    newNode->next = head;
+    head->prev = newNode;
+
+    head = newNode;
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::insertAtEnd(const Key& k, const Info& inf)
+{
+    if (head == nullptr)
+    {
+        Node *newNode = new Node();
+        newNode->key = k;
+        newNode->info = inf;
+        newNode->next = newNode;
+        newNode->prev = newNode;
+
+        head = newNode;
+
+        return;
+    }
+
+    Node *last = head->prev;
+
+    Node *newNode = new Node();
+    newNode->key = k;
+    newNode->info = inf;
+
+    newNode->prev = last;
+    last->next = newNode;
+
+    newNode->next = head;
+    head->prev = newNode;
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::removeAtBeginning()
+{
+    if (head == nullptr)
+        return;
+
+    if (head->next == head)
+    {
+        delete head;
+        head = nullptr;
+
+        return;
+    }
+
+    Node *prev = head->prev;
+    Node *next = head->next;
+
+    prev->next = next;
+    next->prev = prev;
+
+    delete head;
+    head = next;
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::removeAtEnd()
+{
+    if (head == nullptr)
+        return;
+
+    if (head->next == head)
+    {
+        delete head;
+        head = nullptr;
+
+        return;
+    }
+
+    Node *prev = head->prev->prev;
+    //Node *next = head;
+
+    delete head->prev;
+
+    prev->next = head;
+    head->prev = prev;
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::clear()
+{
+    while (head != nullptr)
+        removeAtEnd();
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::printContent()
+{
+    if (head == nullptr)
+        return;
+
+    Node *current = head;
+    int number = 0;
+
+    do
+    {
+        cout << number << "# - Key: " << current->key << ", Info: " << current->info << endl;
+
+        number++;
+        current = current->next;
+    } while (current != head);
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::printContentReverse()
+{
+    if (head == nullptr)
+        return;
+
+
+    if (head->next == head)
+    {
+        cout << "0# - Key: " << head->key << ", Info: " << head->info << endl;
+    }
+
+    Node *current = head->prev;
+    int number = 0;
+
+    do
+    {
+        cout << number << "# - Key: " << current->key << ", Info: " << current->info << endl;
+
+        number++;
+        current = current->prev;
+    } while (current != head);
+}
+
+template <typename Key, typename Info>
+typename Ring<Key, Info>::Iterator Ring<Key, Info>::begin()
+{
+    Ring<Key, Info>::Iterator tempIter = new Ring<Key, Info>::Iterator(head);
+
+    return tempIter;
+}
+
+template <typename Key, typename Info>
+typename Ring<Key, Info>::Iterator Ring<Key, Info>::end()
+{
+    Ring<Key, Info>::Iterator tempIter = new Ring<Key, Info>::Iterator(head->prev);
+
+    return tempIter;
+}
+
+//------------------------------Ring Iterator functions
+
+template <typename Key, typename Info>
+Ring<Key, Info>::Iterator::Iterator()
+{
+    ptr = nullptr;
+    headPtr = nullptr;
+}
+
+template <typename Key, typename Info>
+Ring<Key, Info>::Iterator::Iterator(Node* nodePtr)
+{
+    ptr = nodePtr;
+    headPtr = nodePtr;
+}
+
+template <typename Key, typename Info>
+Ring<Key, Info>::Iterator::Iterator(Ring<Key, Info> ring)
+{
+    ptr = ring.head;
+    headPtr = ring.head;
+}
+
+template <typename Key, typename Info>
+Info Ring<Key, Info>::Iterator::getInfo()
+{
+    if (ptr != nullptr)
+        return ptr->info;
+    else
+        throw "Iterator was nullptr";
+}
+
+template <typename Key, typename Info>
+Key Ring<Key, Info>::Iterator::getKey()
+{
+    if (ptr != nullptr)
+        return ptr->key;
+    else
+        throw "Iterator was nullptr";
+}
+
+template <typename Key, typename Info>
+void Ring<Key, Info>::Iterator::printData(int number)
+{
+    if (ptr != nullptr)
+        cout << number << "# - Key: " << ptr->key << ", Info: " << ptr->info << endl;
+    else
+        cout << "Tried to print an empty iterator" << endl;
+}
+
+template <typename Key, typename Info>
+Info Ring<Key, Info>::Iterator::operator*()
+{
+    if (ptr != nullptr)
+        return ptr->info;
+    else
+        throw "Iterator was nullptr";
+}
+
+template <typename Key, typename Info>
+typename Ring<Key, Info>::Iterator& Ring<Key, Info>::Iterator::operator++()
+{
+    if (ptr != nullptr && headPtr != nullptr && ptr->next != headPtr)
+        ptr = ptr->next;
+
+    return *this;
+}
+
+template <typename Key, typename Info>
+typename Ring<Key, Info>::Iterator Ring<Key, Info>::Iterator::operator++(int)
+{
+    Ring<Key, Info>::Iterator incremented = *this;
+
+    ++(*this);
+    return incremented;
+}
+
+template <typename Key, typename Info>
+typename Ring<Key, Info>::Iterator& Ring<Key, Info>::Iterator::operator--()
+{
+    if (ptr != nullptr && headPtr != nullptr && ptr != headPtr)
+        ptr = ptr->prev;
+
+    return *this;
+}
+
+template <typename Key, typename Info>
+typename Ring<Key, Info>::Iterator Ring<Key, Info>::Iterator::operator--(int)
+{
+    Ring<Key, Info>::Iterator decremented = *this;
+
+    --(*this);
+    return decremented;
+}
+
+template <typename Key, typename Info>
+bool Ring<Key, Info>::Iterator::operator==(const Ring<Key, Info>::Iterator& iter)
+{
+    if (ptr == iter->ptr)
+        return true;
+    else
+        return false;
+}
+
+template <typename Key, typename Info>
+bool Ring<Key, Info>::Iterator::operator!=(const Ring<Key, Info>::Iterator& iter)
+{
+    if (operator==(this))
+        return false;
+    else
+        return true;
+}
+
+
+template <typename Key, typename Info>
+bool Ring<Key, Info>::Iterator::isLast()
+{
+    cout << (ptr != nullptr) << " " << (headPtr != nullptr) << " " << (ptr->next == headPtr) << endl;
+    if (ptr != nullptr && headPtr != nullptr && ptr->next == headPtr)
+        return true;
+    else
+        return false;
+}
+
+template <typename Key, typename Info>
+bool Ring<Key, Info>::Iterator::isFirst()
+{
+    if (ptr != nullptr && headPtr != nullptr && ptr == headPtr)
+        return true;
+    else
+        return false;
+}