feat: value_compare must be generic in RedBlack and BST

Author: mylastresort

include/functional.hpp

@@ -1,6 +1,8 @@
 #ifndef FUNCTIONAL_HPP
 #define FUNCTIONAL_HPP
 
+#include <climits>
+
 namespace ft
 {
 
@@ -15,8 +17,40 @@ template <class T> struct greater
   {
     return first > second;
   }
+
+  static const int TEST_MIN = INT_MAX;
+  static const int TEST_MAX = INT_MIN;
+};
+
+template <class T> struct less
+{
+  bool operator()(const T& first, const T& second) const
+  {
+    return first < second;
+  }
+
+  template <class U> bool operator()(const T& first, const U& second) const
+  {
+    return first < second;
+  }
+
+  static const int TEST_MIN = INT_MIN;
+  static const int TEST_MAX = INT_MAX;
+};
+
+template <class c, class T> struct notCompare : public c
+{
+  bool operator()(const T& first, const T& second) const
+  {
+    return !c::operator()(first, second);
+  }
+
+  template <class U> bool operator()(const T& first, const U& second) const
+  {
+    return !c::operator()(first, second);
+  }
 };
 
 } // namespace ft
 
-#endif
+#endif

include/tree/BinarySearchTree.hpp

@@ -4,24 +4,17 @@
 #include "__except__.hpp"
 #include "__macros__.hpp"
 #include "_phc.hpp"
+#include "functional.hpp"
 #include "iterator.hpp"
 
 namespace ft
 {
 
-struct less
+template <class Comp> struct value_compare
 {
-  bool operator()(const int& a, const int& b) const
-  {
-    return a < b;
-  }
-};
-
-struct value_compare
-{
-  less c;
+  Comp c;
 
-  value_compare(less c = less()) : c(c)
+  value_compare(Comp c = Comp()) : c(c)
   {
   }
 
@@ -31,7 +24,7 @@ struct value_compare
   }
 };
 
-class TreeNode
+template <class Comp> class TreeNode
 {
 protected:
   int* _val;
@@ -56,31 +49,34 @@ class TreeNode
     return !is(val);
   }
 
-  bool compare(const value_compare& cmp, const int& val) const
+  bool compare(const value_compare<Comp>& cmp, const int& val) const
   {
     return cmp(getValue(), val);
   }
 
-  bool notCompare(const value_compare& cmp, const int& val) const
+  bool notCompare(const value_compare<Comp>& cmp, const int& val) const
   {
     return !compare(cmp, val);
   }
 };
 
-template <class Node> class BinarySearchTree;
+template <class Comp, class Node> class BinarySearchTree;
 
-class BinaryTreeNode : public TreeNode
+template <class Comp> class BinaryTreeNode : public TreeNode<Comp>
 {
-  friend class BinarySearchTree<BinaryTreeNode>;
+  friend class BinarySearchTree<Comp, BinaryTreeNode>;
 
 protected:
   BinaryTreeNode* _left;
   BinaryTreeNode* _right;
 
 public:
+  typedef ft::value_compare<Comp> value_compare;
+  typedef Comp                    comp;
+
   BinaryTreeNode(
           int* _val, BinaryTreeNode* _left = NUL, BinaryTreeNode* _right = NUL)
-      : TreeNode(_val), _left(_left), _right(_right)
+      : TreeNode<Comp>(_val), _left(_left), _right(_right)
   {
   }
 
@@ -168,11 +164,13 @@ template <class Node> class BinaryTree
   typedef const int*          pointer;
 
 protected:
-  pnode_t                _root;
-  size_t                 _sz;
-  std::allocator<node_t> _a_node_t;
-  allocator_type         _a_t;
-  value_compare          _c;
+  pnode_t                      _root;
+  size_t                       _sz;
+  std::allocator<node_t>       _a_node_t;
+  allocator_type               _a_t;
+  typename Node::value_compare _c;
+
+  typedef typename Node::comp comp;
 
 public:
   size_t size() const
@@ -472,15 +470,16 @@ template <class Node> class BinarySearchTreeIterator
   }
 };
 
-template <class Node = BinaryTreeNode>
+template <class Comp = less<int>, class Node = BinaryTreeNode<Comp> >
 class BinarySearchTree : public BinaryTree<Node>
 {
 protected:
-  using typename BinaryTree<Node>::pnode_t;
-
 public:
+  using typename BinaryTree<Node>::pnode_t;
+  using typename BinaryTree<Node>::node_t;
   using typename BinaryTree<Node>::value_type;
   using typename BinaryTree<Node>::size_type;
+  using typename BinaryTree<Node>::comp;
 
   typedef BinarySearchTreeIterator<Node> iterator;
   typedef ft::reverse_iterator<BinarySearchTreeIterator<Node> > reverse_iterator;

include/tree/RedBlackTree.hpp

@@ -14,15 +14,18 @@ enum Color
   BLACK
 };
 
-struct RBNode : public TreeNode
+template <class Comp = less<int> > struct RBNode : public TreeNode<Comp>
 {
+  typedef ft::value_compare<Comp> value_compare;
+  typedef Comp                    comp;
+
   RBNode* _parent;
   RBNode* _left;
   RBNode* _right;
   Color   _color;
 
   RBNode(int* _val, RBNode* _left = NUL, RBNode* _right = NUL, RBNode* _parent = NUL)
-      : TreeNode(_val), _parent(_parent), _left(_left), _right(_right),
+      : TreeNode<Comp>(_val), _parent(_parent), _left(_left), _right(_right),
         _color(RED)
   {
   }
@@ -201,20 +204,30 @@ struct RBNode : public TreeNode
   }
 };
 
-class RedBlackTree : public BinarySearchTree<RBNode>
+template <class Comp = less<int> >
+class RedBlackTree : public BinarySearchTree<Comp, RBNode<Comp> >
 {
+protected:
+  using typename BinarySearchTree<Comp, RBNode<Comp> >::pnode_t;
+  using typename BinarySearchTree<Comp, RBNode<Comp> >::node_t;
+
+public:
+  using typename BinarySearchTree<Comp, RBNode<Comp> >::value_type;
+  using typename BinarySearchTree<Comp, RBNode<Comp> >::size_type;
+  using typename BinarySearchTree<Comp, RBNode<Comp> >::comp;
+
 public:
   RedBlackTree()
   {
   }
 
   void insert(const value_type& val)
   {
-    pnode_t node = BinarySearchTree::insert(val);
+    pnode_t node = BinarySearchTree<Comp, RBNode<Comp> >::insert(val);
     if (node != NUL)
       rebalanceInsertion(node);
-    if (hasRoot())
-      ASSERT(getRoot().is(BLACK));
+    if (this->hasRoot())
+      ASSERT(this->getRoot().is(BLACK));
   }
 
   void rebalanceInsertion(pnode_t node)
@@ -245,8 +258,8 @@ class RedBlackTree : public BinarySearchTree<RBNode>
         break;
       }
     }
-    getRoot().set(BLACK);
-    ASSERT(getRoot().is(BLACK));
+    this->getRoot().set(BLACK);
+    ASSERT(this->getRoot().is(BLACK));
   }
 
   void handleCaseThreeInsertion(
@@ -305,7 +318,7 @@ class RedBlackTree : public BinarySearchTree<RBNode>
     // switch Y parent and X Parent
     pnode_t xParent = x->getParentAddr();
     if (xParent == NUL)
-      setRoot(y);
+      this->setRoot(y);
     else if (x->getPosition() == LEFT)
       xParent->setLeft(y);
     else
@@ -334,7 +347,7 @@ class RedBlackTree : public BinarySearchTree<RBNode>
 
   void erase(const value_type& val)
   {
-    pnode_t  p = find(val);
+    pnode_t  p = this->find(val);
     pnode_t  x = NUL;
     pnode_t  pa = NUL;
     Position pos;
@@ -349,9 +362,9 @@ class RedBlackTree : public BinarySearchTree<RBNode>
     else
       handleCaseThreeDeletion(p, pa, x, pos);
 
-    setSize(size() - 1);
+    this->setSize(this->size() - 1);
     rebalanceDeletion(p->getColor(), pa, x, pos);
-    deleteNode(p);
+    this->deleteNode(p);
   }
 
   void rebalanceDeletion(Color clr, pnode_t pa, pnode_t x, Position pos)
@@ -453,7 +466,7 @@ class RedBlackTree : public BinarySearchTree<RBNode>
     ASSERT_NOT_NUL(node);
     ASSERT(node->hasRight());
     ASSERT(node->getRight().hasLeft());
-    pnode_t succ = upper_bound(node);
+    pnode_t succ = this->upper_bound(node);
     ASSERT(node != succ);
 
     pnode_t parent = node->getParentAddr();
@@ -462,7 +475,7 @@ class RedBlackTree : public BinarySearchTree<RBNode>
     ASSERT(succ != right);
 
     if (parent == NUL)
-      setRoot(succ);
+      this->setRoot(succ);
     else if (node->getPosition() == LEFT)
       parent->setLeft(succ);
     else
@@ -500,7 +513,7 @@ class RedBlackTree : public BinarySearchTree<RBNode>
     ASSERT_NOT_NUL(right);
 
     if (parent == NUL)
-      setRoot(right);
+      this->setRoot(right);
     else if (node->getPosition() == LEFT)
       parent->setLeft(right);
     else
@@ -528,7 +541,7 @@ class RedBlackTree : public BinarySearchTree<RBNode>
 
     pos = LEFT;
     if (parent == NUL)
-      setRoot(left);
+      this->setRoot(left);
     else if (node->getPosition() == LEFT)
     {
       parent->setLeft(left);

tests/stamim_tester/main.cpp

@@ -1,4 +1,5 @@
 #include "main.hpp"
+#include "functional.hpp"
 #include "tree/BinarySearchTreeTest.hpp"
 #include "tree/RedBlackTreeTest.hpp"
 
@@ -25,6 +26,13 @@ int main()
   test_vector();
   test_deque();
   test_list();
-  test_bst<ft::BinarySearchTreeTest>();
-  test_bst<ft::RedBlackTreeTest>();
+
+  test_bst<ft::BinarySearchTreeTest<> >();
+  test_bst<ft::RedBlackTreeTest<> >();
+
+  test_bst<ft::BinarySearchTreeTest<ft::less<int> > >();
+  test_bst<ft::RedBlackTreeTest<ft::less<int> > >();
+
+  test_bst<ft::BinarySearchTreeTest<ft::greater<int> > >();
+  test_bst<ft::RedBlackTreeTest<ft::greater<int> > >();
 }

tests/stamim_tester/tree/BinarySearchTreeTest.hpp

@@ -7,25 +7,26 @@
 namespace ft
 {
 
-class BinarySearchTreeTest : public BinarySearchTree<>
+template <class Comp = less<int> >
+class BinarySearchTreeTest : public BinarySearchTree<Comp>
 {
   // TODO: add check: traversal from the null element works
 public:
-  void insert(const value_type& val)
+  void insert(const typename BinarySearchTree<Comp>::value_type& val)
   {
-    size_t i = size();
+    size_t i = this->size();
     bool   count = this->count(val) >= 1;
-    BinarySearchTree::insert(val);
+    BinarySearchTree<Comp>::insert(val);
     assert(isBinarySearchTree(*this));
     assert(isInOrderTraversalSorted(*this));
     assert(hasCorrectSize(*this, count ? i : i + 1));
   }
 
-  void erase(const value_type& val)
+  void erase(const typename BinarySearchTree<Comp>::value_type& val)
   {
-    size_t i = size();
+    size_t i = this->size();
     bool   count = this->count(val) >= 1;
-    BinarySearchTree::erase(val);
+    BinarySearchTree<Comp>::erase(val);
     assert(isBinarySearchTree(*this));
     assert(isInOrderTraversalSorted(*this));
     assert(hasCorrectSize(*this, count ? i - 1 : i));
@@ -52,7 +53,7 @@ class BinarySearchTreeTest : public BinarySearchTree<>
   {
     if (!tree.hasRoot())
       return true;
-    return _isBST(tree, tree.getRoot(), INT_MIN, INT_MAX);
+    return _isBST(tree, tree.getRoot(), tree._c.c.TEST_MIN, tree._c.c.TEST_MAX);
   }
 
   struct BalancedTreeTest