Map node/identifier in an array and implement newIdentifier()

expression_node.h

@@ -6,7 +6,9 @@
 
 class ExpressionNode : public TreeNode {
 public:
-  ExpressionNode() : TreeNode(Pool()->generateIdentifier()) {}
+  ExpressionNode() : TreeNode(Pool()->generateIdentifier()) {
+    Pool()->registerNode(this);
+  }
 
   // TODO: operator new and delte
   // this behavior is the same for every TreeNode

tree_pool.cpp

@@ -23,22 +23,8 @@ void TreePool::dealloc(void * ptr) {
 }
 
 TreeNode * TreePool::node(int identifier) const {
-  for (TreeNode * node : *this) {
-    if (node->identifier() == identifier) {
-      return node;
-    }
-  }
-  /*
-  TreeNode * node = const_cast<TreeNode *>(reinterpret_cast<const TreeNode *>(m_buffer));
-  TreeNode * endOfPool = reinterpret_cast<TreeNode *>(m_cursor);
-  while (node < endOfPool) {
-    if (node->identifier() == identifier) {
-      return node;
-    }
-    node = node->next();
-  }
-  */
-  return nullptr;
+  assert(identifier >= 0 && identifier <= MaxNumberOfNodes);
+  return m_nodeForIdentifier[identifier];
 }
 
 static inline void swap(uint32_t * a, uint32_t * b) {

tree_pool.h

@@ -7,7 +7,7 @@
 
 class TreePool {
 public:
-  TreePool() : m_lastIdentifier(0), m_cursor(m_buffer) {}
+  TreePool() : m_cursor(m_buffer) { }
 
   template <class T>
   TreeNode * createTreeNode() {
@@ -21,13 +21,20 @@ public:
   }
 
   int generateIdentifier() {
-    printf("Generating identifier %d\n", m_lastIdentifier);
-    /* For now we're not bothering with making sure the identifiers are indeed
-     * unique. We're just assuming we'll never overflow... */
-    //assert(node(m_lastIdentifier) == nullptr);
-    return m_lastIdentifier++;
+    int newIdentifier = -1;
+    for (int i = 0; i < MaxNumberOfNodes; i++) {
+      if (m_nodeForIdentifier[i] == nullptr) {
+        newIdentifier = i;
+        break;
+      }
+    }
+    printf("Generating identifier %d\n", newIdentifier);
+    return newIdentifier;
   }
-  void reclaimIdentifier(int identifier) {
+
+  void freeIdentifier(int identifier) {
+    assert(identifier >= 0 && identifier < MaxNumberOfNodes);
+    m_nodeForIdentifier[identifier] = nullptr;
   }
 
   void * alloc(size_t size);
@@ -38,14 +45,23 @@ public:
   TreeNode * first() const { return reinterpret_cast<TreeNode *>(const_cast<char *>(m_buffer)); }
   TreeNode * last() const { return reinterpret_cast<TreeNode *>(const_cast<char *>(m_cursor)); }
 
+  void registerNode(TreeNode * node) {
+    m_nodeForIdentifier[node->identifier()] = node;
+  }
+
+  void renameNode(TreeNode * node) {
+    node->rename(generateIdentifier());
+    registerNode(node);
+  }
+
   TreeNode * deepCopy(TreeNode * node) {
     size_t size = node->deepSize();
     void * ptr = alloc(size);
     memcpy(ptr, static_cast<void *>(node), size);
     TreeNode * copy = reinterpret_cast<TreeNode *>(ptr);
-    copy->rename(generateIdentifier());
+    renameNode(copy);
     for (TreeNode * child : copy->depthFirstChildren()) {
-      child->rename(generateIdentifier());
+      renameNode(child);
     }
     return copy;
   }
@@ -59,9 +75,12 @@ private:
   TreeNode::DepthFirst::Iterator begin() const { return TreeNode::DepthFirst::Iterator(first()); }
   TreeNode::DepthFirst::Iterator end() const { return TreeNode::DepthFirst::Iterator(last()); }
 
-  int m_lastIdentifier;
   char * m_cursor;
-  char m_buffer[256];
+
+  constexpr static int BufferSize = 256;
+  char m_buffer[BufferSize];
+  constexpr static int MaxNumberOfNodes = BufferSize/sizeof(TreeNode);
+  TreeNode * m_nodeForIdentifier[MaxNumberOfNodes];
 };
 
 #endif