Fixing memory leak with RefPtr

src/Engine/Containers/Array.h

@@ -1,5 +1,7 @@
 #pragma once
-#include "MinimalEngine.h"
+#include "EngineTypes.h"
+#include <initializer_list>
+#include <iterator>
 #include <assert.h>
 
 #ifndef DEFAULT_ALLOC_SIZE
@@ -95,11 +97,15 @@ namespace Seele
 				_data = other._data;
 				other._data = nullptr;
 			}
+			return *this;
 		}
 		~Array()
 		{
-			free(_data);
-			_data = nullptr;
+			if(_data)
+			{
+				free(_data);
+				_data = nullptr;
+			}
 		}
 		template<typename X>
 		class IteratorBase {
@@ -132,7 +138,7 @@ namespace Seele
 			{
 				return p == other.p;
 			}
-			inline bool operator-(const IteratorBase& other)
+			inline int operator-(const IteratorBase& other)
 			{
 				return p - other.p;
 			}
@@ -140,17 +146,36 @@ namespace Seele
 				p++;
 				return *this;
 			}
+			IteratorBase& operator--() {
+				p--;
+				return *this;
+			}
 			IteratorBase operator++(int) {
 				IteratorBase tmp(*this);
 				++*this;
 				return tmp;
 			}
+			IteratorBase operator--(int) {
+				IteratorBase tmp(*this);
+				--*this;
+				return tmp;
+			}
 		private:
 			X* p;
 		};
 		typedef IteratorBase<T> Iterator;
 		typedef IteratorBase<const T> ConstIterator;
 
+		bool operator==(const Array& other)
+		{
+			return _data == other._data;
+		}
+
+		bool operator!=(const Array& other)
+		{
+			return !(*this == other);
+		}
+
 		Iterator find(const T& item)
 		{
 			for (int i = 0; i < arraySize; ++i)
@@ -179,8 +204,8 @@ namespace Seele
 				allocated = calculateGrowth(newSize);
 				void* tempArray = malloc(sizeof(T) * allocated);
 				assert(tempArray != nullptr);
+				std::memset(tempArray, 0, sizeof(T) * allocated);
 				std::memcpy(tempArray, _data, arraySize * sizeof(T));
-				memset(tempArray, 0, sizeof(T) * allocated);
 				delete _data;
 				_data = (T*)tempArray;
 			}
@@ -218,7 +243,8 @@ namespace Seele
 			}
 			else
 			{
-				T* newData = new T[newSize];
+				T* newData = (T*)malloc(newSize * sizeof(T));
+				assert(newData != nullptr);
 				allocated = newSize;
 				std::memcpy(newData, _data, sizeof(T) * arraySize);
 				arraySize = newSize;
@@ -243,6 +269,10 @@ namespace Seele
 		{
 			return _data[arraySize - 1];
 		}
+		void pop()
+		{
+			arraySize--;
+		}
 		T& operator[](int index) const
 		{
 			assert(index >= 0 && index < arraySize);

src/Engine/Containers/Map.h

@@ -37,6 +37,17 @@ namespace Seele
 				, rightChild(nullptr)
 				, pair(K(), V())
 			{}
+			~Node()
+			{
+				if(leftChild != nullptr)
+				{
+					delete leftChild;
+				}
+				if(rightChild != nullptr)
+				{
+					delete rightChild;
+				}
+			}
 		};
 
 	public:
@@ -44,16 +55,8 @@ namespace Seele
 			: root(nullptr)
 		{}
 		~Map()
-		{}
-		V& operator[](const K& key)
 		{
-			root = splay(root, key);
-			if (root == nullptr || root->pair.key < key || key < root->pair.key)
-			{
-				root = insert(root, key);
-			}
-			refreshIterators();
-			return root->pair.value;
+			delete root;
 		}
 		class Iterator {
 		public:
@@ -65,10 +68,14 @@ namespace Seele
 
 			Iterator(Node* x = nullptr)
 				: node(x)
-			{
-			}
+			{}
+			Iterator(Node* x, Array<Node*>&& beginIt)
+				: node(x)
+				, traversal(std::move(beginIt))
+			{}
 			Iterator(const Iterator& i)
 				: node(i.node)
+				, traversal(i.traversal)
 			{}
 			reference operator*() const
 			{
@@ -87,11 +94,31 @@ namespace Seele
 				return node == other.node;
 			}
 			Iterator& operator++() {
-				node++;
+				node = node->rightChild;
+				while(node != nullptr && node->leftChild != nullptr)
+				{
+					traversal.add(node);
+					node = node->leftChild;
+				}
+				if(node == nullptr && traversal.size() > 0)
+				{
+					node = traversal.back();
+					traversal.pop();
+				}
 				return *this;
 			}
 			Iterator& operator--() {
-				node--;
+				node = node->leftChild;
+				while(node != nullptr && node->rightchild != nullptr)
+				{
+					traversal.add(node);
+					node = node->rightChild;
+				}
+				if(node == nullptr && traversal.size() > 0)
+				{
+					node = traversal.back();
+					traversal.pop();
+				}
 				return *this;
 			}
 			Iterator operator--(int) {
@@ -106,7 +133,18 @@ namespace Seele
 			}
 		private:
 			Node* node;
+			Array<Node*> traversal;
 		};
+		V& operator[](const K& key)
+		{
+			root = splay(root, key);
+			if (root == nullptr || root->pair.key < key || key < root->pair.key)
+			{
+				root = insert(root, key);
+			}
+			refreshIterators();
+			return root->pair.value;
+		}
 		Iterator find(const K& key)
 		{
 			root = splay(root, key);
@@ -116,6 +154,12 @@ namespace Seele
 			}
 			return Iterator(root);
 		}
+		Iterator erase(const K& key)
+		{
+			root = remove(root, key);
+			refreshIterators();
+			return Iterator(root);
+		}
 		bool exists(const K& key)
 		{
 			return find(key) != endIt;
@@ -131,11 +175,40 @@ namespace Seele
 	private:
 		void refreshIterators()
 		{
-			beginIt = Iterator(&nodes[0]);
-			endIt = Iterator(&nodes[0] + nodes.size());
+			Node* beginNode = root;
+			if(root == nullptr)
+			{
+				beginIt = Iterator(nullptr);
+			}
+			else
+			{
+				Array<Node*> beginTraversal;
+				while(beginNode != nullptr)
+				{	
+					beginTraversal.add(beginNode);
+					beginNode = beginNode->leftChild;
+				}
+				beginNode = beginTraversal.back();
+				beginTraversal.pop();
+				beginIt = Iterator(beginNode, std::move(beginTraversal));
+			}
+			Node* endNode = root;
+			if(root == nullptr)
+			{
+				endIt = Iterator(nullptr);
+			}
+			else
+			{
+				Array<Node*> endTraversal;
+				while(endNode != nullptr)
+				{
+					endTraversal.add(endNode);
+					endNode = endNode->rightChild;
+				}
+				endIt = Iterator(endNode, std::move(endTraversal));
+			}
 		}
 		Node* root;
-		Array<Node> nodes;
 		Iterator beginIt;
 		Iterator endIt;
 		Node* rotateRight(Node* node)
@@ -154,7 +227,7 @@ namespace Seele
 		}
 		Node* makeNode(const K& key)
 		{
-			return &nodes.add(Node(key));
+			return new Node(key);
 		}
 		Node* insert(Node* root, const K& key)
 		{
@@ -188,7 +261,7 @@ namespace Seele
 
 			root = splay(root, key);
 
-			if (key != root->pair.key)
+			if (root->pair.key < key || key < root->pair.key)
 				return root;
 
 			if (!root->leftChild)
@@ -203,7 +276,8 @@ namespace Seele
 				root = splay(root->leftChild, key);
 				root->rightChild = temp->rightChild;
 			}
-			nodes.remove(temp);
+			temp->leftChild = nullptr;
+			temp->rightChild = nullptr;
 			delete temp;
 			return root;
 		}