New TreeNode methods

tree_node.cpp

@@ -2,7 +2,7 @@
 #include "tree_pool.h"
 #include "expression_node.h"
 
-TreeNode * TreeNode::treeParent() const {
+TreeNode * TreeNode::parentTree() const {
 // Choose between those two algorithms: the first has complexity O(numberNodes) but uses 0(3maxNumberNodes) space
 // The second is much clearer for the reader and uses no space, but has complexity 0
 #if 0
@@ -46,6 +46,16 @@ TreeNode * TreeNode::treeParent() const {
 #endif
 }
 
+TreeNode * TreeNode::editableRootTree() {
+  for (TreeNode * root : TreePool::sharedPool()->roots()) {
+    if (hasAncestor(root, true)) {
+      return root;
+    }
+  }
+  assert(false);
+  return nullptr;
+}
+
 int TreeNode::numberOfDescendants(bool includeSelf) const {
   int result = includeSelf ? 1 : 0;
   for (TreeNode * child : depthFirstChildren()) {
@@ -54,7 +64,7 @@ int TreeNode::numberOfDescendants(bool includeSelf) const {
   return result;
 }
 
-TreeNode * TreeNode::treeChildAtIndex(int i) const {
+TreeNode * TreeNode::childTreeAtIndex(int i) const {
   assert(i >= 0);
   assert(i < numberOfChildren());
   TreeNode * child = next();
@@ -66,6 +76,60 @@ TreeNode * TreeNode::treeChildAtIndex(int i) const {
   return child;
 }
 
+int TreeNode::indexOfChild(const TreeNode * child) const {
+  if (child == nullptr) {
+    return -1;
+  }
+  int childrenCount = numberOfChildren();
+  TreeNode * childAtIndexi = next();
+  for (int i = 0; i < childrenCount; i++) {
+    if (childAtIndexi == child) {
+      return i;
+    }
+    childAtIndexi = childAtIndexi->nextSibling();
+  }
+  return -1;
+}
+
+bool TreeNode::hasChild(const TreeNode * child) const {
+  if (child == nullptr) {
+    return false;
+  }
+  for (TreeNode * c : directChildren()) {
+    if (child == c) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool TreeNode::hasAncestor(const TreeNode * node, bool includeSelf) const {
+  if (includeSelf && node == this) {
+    return true;
+  }
+  for (TreeNode * t : node->depthFirstChildren()) {
+    if (this == t) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool TreeNode::hasSibling(const TreeNode * e) const {
+  if (e == nullptr) {
+    return false;
+  }
+  TreeNode * parent = parentTree();
+  if (parent == nullptr) {
+    return false;
+  }
+  for (TreeNode * childNode : parent->directChildren()) {
+    if (childNode == e) {
+      return true;
+    }
+  }
+  return false;
+}
 
 void TreeNode::release() {
   printf("Release %d(%p)\n", m_identifier, this);