Implemented basic containers and ref pointers

2020-02-25 00:45:20 +01:00
parent 4c491a9378
commit a14237d6ce
31 changed files with 1212 additions and 36 deletions
@@ -0,0 +1,281 @@
+#pragma once
+#include "MinimalEngine.h"
+#include <assert.h>
+
+#ifndef DEFAULT_ALLOC_SIZE
+#define DEFAULT_ALLOC_SIZE 16
+#endif
+
+namespace Seele 
+{
+	template<typename T>
+	struct Array
+	{
+	public:
+		Array()
+			: allocated(DEFAULT_ALLOC_SIZE)
+			, arraySize(0)
+		{
+			_data = new T[DEFAULT_ALLOC_SIZE];
+			refreshIterators();
+		}
+		Array(size_t size, T value = T())
+			: allocated(size)
+			, arraySize(size)
+		{
+			_data = new T[size];
+			for (int i = 0; i < size; ++i)
+			{
+				_data[i] = value;
+			}
+			refreshIterators();
+		}
+		~Array()
+		{
+			delete _data;
+			_data = nullptr;
+		}
+		template<typename X>
+		class IteratorBase {
+		public:
+			typedef std::forward_iterator_tag iterator_category;
+			typedef X value_type;
+			typedef std::ptrdiff_t difference_type;
+			typedef X& reference;
+			typedef X* pointer;
+
+			IteratorBase(X* x = nullptr)
+				: p(x)
+			{}
+			IteratorBase(const IteratorBase& i)
+				: p(i.p)
+			{}
+			reference operator*() const
+			{
+				return *p;
+			}
+			pointer operator->() const
+			{
+				return p;
+			}
+			inline bool operator!=(const IteratorBase& other)
+			{
+				return p != other.p;
+			}
+			inline bool operator==(const IteratorBase& other)
+			{
+				return p == other.p;
+			}
+			inline bool operator-(const IteratorBase& other)
+			{
+				return p - other.p;
+			}
+			IteratorBase& operator++() {
+				p++;
+				return *this;
+			}
+			IteratorBase operator++(int) {
+				IteratorBase tmp(*this);
+				++*this;
+				return tmp;
+			}
+		private:
+			X* p;
+		};
+		typedef IteratorBase<T> Iterator;
+		typedef IteratorBase<const T> ConstIterator;
+
+		Iterator find(const T& item)
+		{
+			for (int i = 0; i < arraySize; ++i)
+			{
+				if (_data[i] == item)
+				{
+					return Iterator(&_data[i]);
+				}
+			}
+			return endIt;
+		}
+		Iterator begin()
+		{
+			return beginIt;
+		}
+		Iterator end()
+		{
+			return endIt;
+		}
+
+		T& add(const T& item)
+		{
+			if (arraySize == allocated)
+			{
+				allocated += DEFAULT_ALLOC_SIZE;
+				T* tempArray = new T[allocated];
+				std::memcpy(tempArray, _data, arraySize * sizeof(T));
+				delete _data;
+				_data = tempArray;
+			}
+			_data[arraySize++] = item;
+			refreshIterators();
+			return _data[arraySize - 1];
+		}
+		void remove(Iterator it, bool keepOrder = true)
+		{
+			remove(it - beginIt, keepOrder);
+		}
+		void remove(int index, bool keepOrder = true)
+		{
+			if (keepOrder)
+			{
+				std::memcpy(&_data[index], &_data[index + 1], sizeof(T) * (arraySize - index));
+			}
+			else
+			{
+				_data[index] = _data[arraySize - 1];
+			}
+			arraySize--;
+		}
+		void clear()
+		{
+			arraySize = 0;
+			allocated = 0;
+			refreshIterators();
+		}
+		void resize(uint32 newSize)
+		{
+			if (newSize < allocated)
+			{
+				arraySize = newSize;
+			}
+			else
+			{
+				T* newData = new T[newSize];
+				allocated = newSize;
+				std::memcpy(newData, _data, sizeof(T) * arraySize);
+				arraySize = newSize;
+				delete _data;
+				_data = newData;
+			}
+			refreshIterators();
+		}
+		inline uint32 size() const
+		{
+			return arraySize;
+		}
+		inline uint32 capacity() const
+		{
+			return allocated;
+		}
+		inline T* data() const
+		{
+			return _data;
+		}
+		T& back() const
+		{
+			return _data[arraySize - 1];
+		}
+		T& operator[](int index) const
+		{
+			assert(index >= 0 && index < arraySize);
+			return _data[index];
+		}
+	private:
+		void refreshIterators()
+		{
+			beginIt = Iterator(_data);
+			endIt = Iterator(_data + arraySize);
+		}
+		uint32 arraySize;
+		uint32 allocated;
+		Iterator beginIt;
+		Iterator endIt;
+		T* _data;
+	};
+
+	template<typename T, uint32 N>
+	struct StaticArray
+	{
+	public:
+		StaticArray()
+		{
+			beginIt = Iterator(_data);
+			endIt = Iterator(_data + N);
+		}
+		StaticArray(T value)
+		{
+			for (int i = 0; i < N; ++i)
+			{
+				_data[i] = value;
+			}
+			beginIt = Iterator(_data);
+			endIt = Iterator(_data + N);
+		}
+		~StaticArray()
+		{}
+
+		inline uint32 size() const
+		{
+			return N;
+		}
+		inline T* data() const
+		{
+			return _data;
+		}
+		T& operator[](int index)
+		{
+			assert(index >= 0 && index < N);
+			return _data[index];
+		}
+
+		template<typename X>
+		class IteratorBase {
+		public:
+			typedef std::forward_iterator_tag iterator_category;
+			typedef X value_type;
+			typedef std::ptrdiff_t difference_type;
+			typedef X& reference;
+			typedef X* pointer;
+
+			IteratorBase(X* x = nullptr)
+				: p(x)
+			{}
+			IteratorBase(const IteratorBase& i)
+				: p(i.p)
+			{}
+			reference operator*() const
+			{
+				return *p;
+			}
+			pointer operator->() const
+			{
+				return p;
+			}
+			inline bool operator!=(const IteratorBase& other)
+			{
+				return p != other.p;
+			}
+			inline bool operator==(const IteratorBase& other)
+			{
+				return p == other.p;
+			}
+			IteratorBase& operator++() {
+				p++;
+				return *this;
+			}
+			IteratorBase operator++(int) {
+				IteratorBase tmp(*this);
+				++*this;
+				return tmp;
+			}
+		private:
+			X* p;
+		};
+		typedef IteratorBase<T> Iterator;
+		typedef IteratorBase<const T> ConstIterator;
+
+	private:
+		T _data[N];
+		Iterator beginIt;
+		Iterator endIt;
+	};
+}
@@ -0,0 +1,3 @@
+target_sources(SeeleEngine
+	PRIVATE
+		Array.h)
@@ -0,0 +1,262 @@
+#pragma once
+#include "Array.h"
+
+namespace Seele
+{
+	template<typename K, typename V>
+	struct Pair
+	{
+	public:
+		Pair()
+			: key(K())
+			, value(V())
+		{}
+		Pair(K key, V value)
+			: key(key)
+			, value(value)
+		{}
+		K key;
+		V value;
+	};
+	template<typename K, typename V>
+	struct Map
+	{
+	private:
+		struct Node
+		{
+			Pair<K, V> pair;
+			Node* leftChild;
+			Node* rightChild;
+			Node(const K& key)
+				: leftChild(nullptr)
+				, rightChild(nullptr)
+				, pair(key, V())
+			{}
+			Node()
+				: leftChild(nullptr)
+				, rightChild(nullptr)
+				, pair(K(), V())
+			{}
+		};
+
+	public:
+		Map()
+			: 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;
+		}
+		class Iterator {
+		public:
+			typedef std::bidirectional_iterator_tag iterator_category;
+			typedef Pair<K, V> value_type;
+			typedef std::ptrdiff_t difference_type;
+			typedef Pair<K, V>& reference;
+			typedef Pair<K, V>* pointer;
+
+			Iterator(Node* x = nullptr)
+				: node(x)
+			{
+			}
+			Iterator(const Iterator& i)
+				: node(i.node)
+			{}
+			reference operator*() const
+			{
+				return node->pair;
+			}
+			pointer operator->() const
+			{
+				return &node->pair;
+			}
+			inline bool operator!=(const Iterator& other)
+			{
+				return node != other.node;
+			}
+			inline bool operator==(const Iterator& other)
+			{
+				return node == other.node;
+			}
+			Iterator& operator++() {
+				node++;
+				return *this;
+			}
+			Iterator& operator--() {
+				node--;
+				return *this;
+			}
+			Iterator operator--(int) {
+				Iterator tmp(*this);
+				++* this;
+				return tmp;
+			}
+			Iterator operator++(int) {
+				Iterator tmp(*this);
+				++* this;
+				return tmp;
+			}
+		private:
+			Node* node;
+		};
+		Iterator find(const K& key)
+		{
+			root = splay(root, key);
+			if (root == nullptr || root->pair.key != key)
+			{
+				return endIt;
+			}
+			return Iterator(root);
+		}
+		bool exists(const K& key)
+		{
+			return find(key) != endIt;
+		}
+		Iterator begin() const
+		{
+			return beginIt;
+		}
+		Iterator end() const
+		{
+			return endIt;
+		}
+	private:
+		void refreshIterators()
+		{
+			beginIt = Iterator(&nodes[0]);
+			endIt = Iterator(&nodes[0] + nodes.size());
+		}
+		Node* root;
+		Array<Node> nodes;
+		Iterator beginIt;
+		Iterator endIt;
+		Node* rotateRight(Node* node)
+		{
+			Node* y = node->leftChild;
+			node->leftChild = y->rightChild;
+			y->rightChild = node;
+			return y;
+		}
+		Node* rotateLeft(Node* node)
+		{
+			Node* y = node->rightChild;
+			node->rightChild = y->leftChild;
+			y->leftChild = node;
+			return y;
+		}
+		Node* makeNode(const K& key)
+		{
+			return &nodes.add(Node(key));
+		}
+		Node* insert(Node* root, const K& key)
+		{
+			if (root == nullptr) return makeNode(key);
+
+			root = splay(root, key);
+
+			if (!(root->pair.key < key || key < root->pair.key)) return root;
+
+			Node* newNode = makeNode(key);
+
+			if (key < root->pair.key)
+			{
+				newNode->rightChild = root;
+				newNode->leftChild = root->leftChild;
+				root->leftChild = nullptr;
+			}
+			else
+			{
+				newNode->leftChild = root;
+				newNode->rightChild = root->rightChild;
+				root->rightChild = nullptr;
+			}
+			return newNode;
+		}
+		Node* remove(Node* root, const K& key)
+		{
+			Node* temp;
+			if (!root)
+				return nullptr;
+
+			root = splay(root, key);
+
+			if (key != root->pair.key)
+				return root;
+
+			if (!root->leftChild)
+			{
+				temp = root;
+				root = root->rightChild;
+			}
+			else
+			{
+				temp = root;
+
+				root = splay(root->leftChild, key);
+				root->rightChild = temp->rightChild;
+			}
+			nodes.remove(temp);
+			delete temp;
+			return root;
+		}
+		Node* splay(Node* root, const K& key)
+		{
+			if (root == nullptr || !(root->pair.key < key || key < root->pair.key))
+			{
+				return root;
+			}
+
+			if (key < root->pair.key)
+			{
+				if (root->leftChild == nullptr)
+					return root;
+
+				if (key < root->leftChild->pair.key)
+				{
+					root->leftChild->leftChild = splay(root->leftChild->leftChild, key);
+
+					root = rotateRight(root);
+				}
+				else if (root->leftChild->pair.key < key)
+				{
+					root->leftChild->rightChild = splay(root->leftChild->rightChild, key);
+
+					if (root->leftChild->rightChild != nullptr)
+					{
+						root->leftChild = rotateLeft(root->leftChild);
+					}
+				}
+				return (root->leftChild == nullptr) ? root : rotateRight(root);
+			}
+			else
+			{
+				if (root->rightChild == nullptr)
+					return root;
+
+				if (key < root->rightChild->pair.key)
+				{
+					root->rightChild->leftChild = splay(root->rightChild->leftChild, key);
+
+					if (root->rightChild->leftChild != nullptr)
+					{
+						root->rightChild = rotateRight(root->rightChild);
+					}
+				}
+				else if (root->rightChild->pair.key < key)
+				{
+					root->rightChild->rightChild = splay(root->rightChild->rightChild, key);
+					root = rotateLeft(root);
+				}
+				return (root->rightChild == nullptr) ? root : rotateLeft(root);
+			}
+		}
+	};
+}