Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Using indices instead of pointers

Browse Source
This commit is contained in:
Dynamitos
2021-11-04 23:47:51 +01:00
parent ca8070ef71
commit 97dcf25a59
2 changed files with 114 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Containers/Array.h
+1 -1
View File
@@ -401,7 +401,7 @@ namespace Seele
} }
void pop() void pop()
{ {
_data[arraySize--].~T(); _data[--arraySize].~T();
markIteratorDirty(); markIteratorDirty();
} }
constexpr inline reference operator[](size_type index) constexpr inline reference operator[](size_type index)
src/Engine/Containers/Map.h
+113 -76
View File
@@ -36,20 +36,25 @@ struct Map
private: private:
struct Node struct Node
{ {
Node *leftChild; size_t self;
Node *rightChild; size_t leftChild;
size_t rightChild;
Pair<K, V> pair; Pair<K, V> pair;
Node() Node()
: leftChild(nullptr), rightChild(nullptr), pair() : self(-1)
, leftChild(-1)
, rightChild(-1)
, pair()
{ {
} }
Node(const Node& other) = default; Node(const Node& other) = default;
Node(Node&& other) = default; Node(Node&& other) = default;
Node& operator=(const Node& other) = default; Node& operator=(const Node& other) = default;
Node& operator=(Node&& other) = default; Node& operator=(Node&& other) = default;
Node(K key) Node(size_t self, K key)
: leftChild(nullptr) : self(self)
, rightChild(nullptr) , leftChild(-1)
, rightChild(-1)
, pair(std::move(key)) , pair(std::move(key))
{ {
} }
@@ -73,8 +78,8 @@ public:
: node(x) : node(x)
{ {
} }
IteratorBase(Node *x, Array<Node *> &&beginIt) IteratorBase(Node *x, Array<size_t> &&beginIt, const Array<Node, NodeAlloc>* nodeContainer)
: node(x), traversal(std::move(beginIt)) : node(x), traversal(std::move(beginIt)), nodeContainer(nodeContainer)
{ {
} }
IteratorBase(const IteratorBase &i) IteratorBase(const IteratorBase &i)
@@ -121,32 +126,34 @@ public:
} }
IteratorBase &operator++() IteratorBase &operator++()
{ {
node = node->rightChild; size_t nextIndex = node->rightChild;
while (node != nullptr && node->leftChild != nullptr) while (nextIndex != -1 && (*nodeContainer)[nextIndex].leftChild != -1)
{ {
traversal.add(node); traversal.add(nextIndex);
node = node->leftChild; nextIndex = (*nodeContainer)[nextIndex].leftChild;
} }
if (node == nullptr && traversal.size() > 0) if (nextIndex == -1 && traversal.size() > 0)
{ {
node = traversal.back(); nextIndex = traversal.back();
traversal.pop(); traversal.pop();
} }
node = nextIndex != -1 ? &(*nodeContainer)[nextIndex] : nullptr;
return *this; return *this;
} }
IteratorBase &operator--() IteratorBase &operator--()
{ {
node = node->leftChild; size_t nextIndex = node->leftChild;
while (node != nullptr && node->rightchild != nullptr) while (nextIndex != -1 && (*nodeContainer)[nextIndex].rightChild != -1)
{ {
traversal.add(node); traversal.add(nextIndex);
node = node->rightChild; nextIndex = (*nodeContainer)[nextIndex].rightchild;
} }
if (node == nullptr && traversal.size() > 0) if (nextIndex == -1 && traversal.size() > 0)
{ {
node = traversal.back(); nextIndex = traversal.back();
traversal.pop(); traversal.pop();
} }
node = nextIndex != -1 ? &(*nodeContainer)[nextIndex] : nullptr;
return *this; return *this;
} }
IteratorBase operator--(int) IteratorBase operator--(int)
@@ -164,7 +171,8 @@ public:
private: private:
Node *node; Node *node;
Array<Node *> traversal; Array<size_t> traversal;
const Array<Node, NodeAlloc>* nodeContainer;
}; };
using Iterator = IteratorBase<Pair<K,V>>; using Iterator = IteratorBase<Pair<K,V>>;
using ConstIterator = IteratorBase<const Pair<K,V>>; using ConstIterator = IteratorBase<const Pair<K,V>>;
@@ -283,7 +291,7 @@ public:
iterator find(const key_type& key) iterator find(const key_type& key)
{ {
root = splay(root, key); root = splay(root, key);
markIteratorDirty(); refreshIterators();
if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key)) if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key))
{ {
return endIt; return endIt;
@@ -293,7 +301,7 @@ public:
iterator find(key_type&& key) iterator find(key_type&& key)
{ {
root = splay(root, std::move(key)); root = splay(root, std::move(key));
markIteratorDirty(); refreshIterators();
if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key)) if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key))
{ {
return endIt; return endIt;
@@ -303,13 +311,13 @@ public:
iterator erase(const key_type& key) iterator erase(const key_type& key)
{ {
root = remove(root, key); root = remove(root, key);
markIteratorDirty(); refreshIterators();
return iterator(root); return iterator(root);
} }
iterator erase(K&& key) iterator erase(K&& key)
{ {
root = remove(root, std::move(key)); root = remove(root, std::move(key));
markIteratorDirty(); refreshIterators();
return iterator(root); return iterator(root);
} }
void clear() void clear()
@@ -365,6 +373,26 @@ public:
} }
private: private:
Node* leftChild(Node* node)
{
if(node->leftChild >= nodeContainer.size()) return nullptr;
return &nodeContainer[node->leftChild];
}
Node* rightChild(Node* node)
{
if(node->rightChild >= nodeContainer.size()) return nullptr;
return &nodeContainer[node->rightChild];
}
Node* leftChild(Node* node) const
{
if(node->leftChild >= nodeContainer.size()) return nullptr;
return &nodeContainer[node->leftChild];
}
Node* rightChild(Node* node) const
{
if(node->rightChild >= nodeContainer.size()) return nullptr;
return &nodeContainer[node->rightChild];
}
void markIteratorDirty() void markIteratorDirty()
{ {
iteratorsDirty = true; iteratorsDirty = true;
@@ -377,40 +405,40 @@ private:
} }
inline Iterator calcBeginIterator() const inline Iterator calcBeginIterator() const
{ {
Node *beginNode = root;
if (root == nullptr) if (root == nullptr)
{ {
return Iterator(nullptr); return Iterator(nullptr);
} }
else else
{ {
Array<Node *> beginTraversal; size_t beginIndex = root->self;
while (beginNode != nullptr) Array<size_t> beginTraversal;
while (beginIndex < nodeContainer.size())
{ {
beginTraversal.add(beginNode); beginTraversal.add(beginIndex);
beginNode = beginNode->leftChild; beginIndex = nodeContainer[beginIndex].leftChild;
} }
beginNode = beginTraversal.back(); Node* beginNode = &nodeContainer[beginTraversal.back()];
beginTraversal.pop(); beginTraversal.pop();
return Iterator(beginNode, std::move(beginTraversal)); return Iterator(beginNode, std::move(beginTraversal), &nodeContainer);
} }
} }
inline Iterator calcEndIterator() const inline Iterator calcEndIterator() const
{ {
Node *endNode = root;
if (root == nullptr) if (root == nullptr)
{ {
return Iterator(nullptr); return Iterator(nullptr);
} }
else else
{ {
Array<Node *> endTraversal; size_t endIndex = root->self;
while (endNode != nullptr) Array<size_t> endTraversal;
while (endIndex < nodeContainer.size())
{ {
endTraversal.add(endNode); endTraversal.add(endIndex);
endNode = endNode->rightChild; endIndex = nodeContainer[endIndex].rightChild;
} }
return Iterator(endNode, std::move(endTraversal)); return Iterator(nullptr, std::move(endTraversal), &nodeContainer);
} }
} }
Array<Node, NodeAlloc> nodeContainer; Array<Node, NodeAlloc> nodeContainer;
@@ -422,16 +450,16 @@ private:
Compare comp; Compare comp;
Node *rotateRight(Node *node) Node *rotateRight(Node *node)
{ {
Node *y = node->leftChild; Node *y = leftChild(node);
node->leftChild = y->rightChild; node->leftChild = y->rightChild;
y->rightChild = node; y->rightChild = node->self;
return y; return y;
} }
Node *rotateLeft(Node *node) Node *rotateLeft(Node *node)
{ {
Node *y = node->rightChild; Node *y = rightChild(node);
node->rightChild = y->leftChild; node->rightChild = y->leftChild;
y->leftChild = node; y->leftChild = node->self;
return y; return y;
} }
template<class KeyType> template<class KeyType>
@@ -439,26 +467,26 @@ private:
{ {
if (r == nullptr) if (r == nullptr)
{ {
return &nodeContainer.emplace(std::forward<KeyType>(key)); return &nodeContainer.emplace(nodeContainer.size(), std::forward<KeyType>(key));
} }
r = splay(r, key); r = splay(r, key);
if (!(comp(r->pair.key, key) || comp(key, r->pair.key))) if (!(comp(r->pair.key, key) || comp(key, r->pair.key)))
return r; return r;
Node *newNode = &nodeContainer.emplace(std::forward<KeyType>(key)); Node *newNode = &nodeContainer.emplace(nodeContainer.size(), std::forward<KeyType>(key));
if (comp(key, r->pair.key)) if (comp(key, r->pair.key))
{ {
newNode->rightChild = r; newNode->rightChild = r->self;
newNode->leftChild = r->leftChild; newNode->leftChild = r->leftChild;
r->leftChild = nullptr; r->leftChild = -1;
} }
else else
{ {
newNode->leftChild = r; newNode->leftChild = r->self;
newNode->rightChild = r->rightChild; newNode->rightChild = r->rightChild;
r->rightChild = nullptr; r->rightChild = -1;
} }
return newNode; return newNode;
} }
@@ -474,31 +502,36 @@ private:
if (comp(r->pair.key, key) || comp(key, r->pair.key)) if (comp(r->pair.key, key) || comp(key, r->pair.key))
return r; return r;
if (!r->leftChild) if (r->leftChild == -1)
{ {
temp = r; temp = r;
r = r->rightChild; r = rightChild(r);
} }
else else
{ {
temp = r; temp = r;
r = splay(r->leftChild, key); r = splay(leftChild(r), key);
r->rightChild = temp->rightChild; r->rightChild = temp->rightChild;
} }
Node& lastNode = nodeContainer.back(); Node& lastNode = nodeContainer.back();
size_t removedIndex = nodeContainer.indexOf(temp); size_t removedIndex = temp->self;
nodeContainer[removedIndex] = std::move(lastNode); //Arrays can only pop back, so we need to move the last element to the deleted index
for(auto it : nodeContainer) if(removedIndex != lastNode.self)
{ {
if(it.leftChild == &lastNode) nodeContainer[removedIndex] = std::move(lastNode);
for(auto it : nodeContainer)
{ {
it.leftChild = &nodeContainer[removedIndex]; if(it.leftChild == lastNode.self)
} {
if(it.rightChild == &lastNode) it.leftChild = removedIndex;
{ }
it.rightChild = &nodeContainer[removedIndex]; if(it.rightChild == lastNode.self)
{
it.rightChild = removedIndex;
}
} }
lastNode.self = removedIndex;
} }
nodeContainer.pop(); nodeContainer.pop();
_size--; _size--;
@@ -514,46 +547,50 @@ private:
if (comp(key, r->pair.key)) if (comp(key, r->pair.key))
{ {
if (r->leftChild == nullptr) if (r->leftChild >= nodeContainer.size())
return r; return r;
if (comp(key, r->leftChild->pair.key)) if (comp(key, leftChild(r)->pair.key))
{ {
r->leftChild->leftChild = splay(r->leftChild->leftChild, key); Node* res = splay(leftChild(leftChild(r)), key);
leftChild(r)->leftChild = res ? res->self : -1;
r = rotateRight(r); r = rotateRight(r);
} }
else if (comp(r->leftChild->pair.key, key)) else if (comp(leftChild(r)->pair.key, key))
{ {
r->leftChild->rightChild = splay(r->leftChild->rightChild, key); Node* res = splay(rightChild(leftChild(r)), key);
leftChild(r)->rightChild = res ? res->self : -1;
if (r->leftChild->rightChild != nullptr) if (leftChild(r)->rightChild < nodeContainer.size())
{ {
r->leftChild = rotateLeft(r->leftChild); r->leftChild = rotateLeft(leftChild(r))->self;
} }
} }
return (r->leftChild == nullptr) ? r : rotateRight(r); return (r->leftChild >= nodeContainer.size()) ? r : rotateRight(r);
} }
else else
{ {
if (r->rightChild == nullptr) if (r->rightChild >= nodeContainer.size())
return r; return r;
if (comp(key, r->rightChild->pair.key)) if (comp(key, rightChild(r)->pair.key))
{ {
r->rightChild->leftChild = splay(r->rightChild->leftChild, key); Node* res = splay(leftChild(rightChild(r)), key);
rightChild(r)->leftChild = res ? res->self : -1;
if (r->rightChild->leftChild != nullptr) if (rightChild(r)->leftChild < nodeContainer.size())
{ {
r->rightChild = rotateRight(r->rightChild); r->rightChild = rotateRight(rightChild(r))->self;
} }
} }
else if (comp(r->rightChild->pair.key, key)) else if (comp(rightChild(r)->pair.key, key))
{ {
r->rightChild->rightChild = splay(r->rightChild->rightChild, key); Node* res = splay(rightChild(rightChild(r)), key);
rightChild(r)->rightChild = res ? res->self : -1;
r = rotateLeft(r); r = rotateLeft(r);
} }
return (r->rightChild == nullptr) ? r : rotateLeft(r); return (r->rightChild >= nodeContainer.size()) ? r : rotateLeft(r);
} }
} }
}; };