modifies AND/OR functions for easier reading through auto return types, removes deprecated test helper function

Author: attwoodn

include/attwoodn/expression_tree.hpp

@@ -162,10 +162,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was AND'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherOp, typename OtherCompValue, typename OtherLeafNode,
-                    std::enable_if<std::is_same<OtherLeafNode, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherLeafNode>* AND (OtherLeafNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherLeafNode>(boolean_op::AND);
+                template<typename OtherOp, typename OtherCompValue>
+                auto* AND (expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>;
+                    ret* op_node = new ret(boolean_op::AND);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -177,10 +177,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was OR'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherOp, typename OtherCompValue, typename OtherLeafNode,
-                    std::enable_if<std::is_same<OtherLeafNode, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherLeafNode>* OR (OtherLeafNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherLeafNode>(boolean_op::OR);
+                template<typename OtherOp, typename OtherCompValue>
+                auto* OR (expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>;
+                    ret* op_node = new ret(boolean_op::OR);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -192,10 +192,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was AND'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherLeftChild, typename OtherRightChild, typename OtherOpNode, 
-                    std::enable_if<std::is_same<OtherOpNode, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherOpNode>* AND (OtherOpNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherOpNode>(boolean_op::AND);
+                template<typename OtherLeftChild, typename OtherRightChild>
+                auto* AND (expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>;
+                    ret* op_node = new ret(boolean_op::AND);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -207,10 +207,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was OR'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherLeftChild, typename OtherRightChild, typename OtherOpNode,
-                    std::enable_if<std::is_same<OtherOpNode, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherOpNode>* OR (OtherOpNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherOpNode>(boolean_op::OR);
+                template<typename OtherLeftChild, typename OtherRightChild>
+                auto* OR (expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>;
+                    ret* op_node = new ret(boolean_op::OR);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -289,10 +289,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was AND'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherOp, typename OtherCompValue, typename OtherLeafNode,
-                    std::enable_if<std::is_same<OtherLeafNode, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherLeafNode>* AND (OtherLeafNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherLeafNode>(boolean_op::AND);
+                template<typename OtherOp, typename OtherCompValue>
+                auto* AND (expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>;
+                    ret* op_node = new ret(boolean_op::AND);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -304,10 +304,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was OR'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherOp, typename OtherCompValue, typename OtherLeafNode,
-                    std::enable_if<std::is_same<OtherLeafNode, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherLeafNode>* OR (OtherLeafNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherLeafNode>(boolean_op::OR);
+                template<typename OtherOp, typename OtherCompValue>
+                auto* OR (expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_leaf_node<Obj, OtherOp, OtherCompValue>>;
+                    ret* op_node = new ret(boolean_op::OR);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -319,10 +319,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was AND'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherLeftChild, typename OtherRightChild, typename OtherOpNode, 
-                    std::enable_if<std::is_same<OtherOpNode, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherOpNode>* AND (OtherOpNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherOpNode>(boolean_op::AND);
+                template<typename OtherLeftChild, typename OtherRightChild>
+                auto* AND (expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>;
+                    ret* op_node = new ret(boolean_op::AND);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;
@@ -334,10 +334,10 @@ namespace attwoodn::expression_tree {
                  * and the other node that was OR'ed with this node. This node becomes the left child. The other node becomes
                  * the right child.
                 */
-                template<typename OtherLeftChild, typename OtherRightChild, typename OtherOpNode,
-                    std::enable_if<std::is_same<OtherOpNode, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>::value>* = nullptr>
-                expression_tree_op_node<Obj, this_type, OtherOpNode>* OR (OtherOpNode* other) {
-                    auto* op_node = new expression_tree_op_node<Obj, this_type, OtherOpNode>(boolean_op::OR);
+                template<typename OtherLeftChild, typename OtherRightChild>
+                auto* OR (expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>* other) {
+                    using ret = expression_tree_op_node<Obj, this_type, expression_tree_op_node<Obj, OtherLeftChild, OtherRightChild>>;
+                    ret* op_node = new ret(boolean_op::OR);
                     op_node->set_left(this);
                     op_node->set_right(other);
                     return op_node;

tests/expression_tree_op_node.cpp

@@ -18,10 +18,10 @@ int main(int argc, char** argv) {
 }
 
 void test_AND_op_node_evaluation() {
-    auto child_expr1 = make_expr(&test_fixture::some_string, op::equals, std::string("hello, world!"));
-    auto child_expr2 = make_expr(&test_fixture::some_uint, op::less_than, (uint16_t) 500);
-
-    auto expr = make_op_node<test_fixture>(child_expr1, node::boolean_op::AND, child_expr2);
+    auto expr = std::unique_ptr<node::expression_tree_node<test_fixture>>(
+        make_expr(&test_fixture::some_string, op::equals, std::string("hello, world!"))
+        ->AND(make_expr(&test_fixture::some_uint, op::less_than, (uint16_t) 500))
+    );
 
     test_fixture fixture;
     fixture.some_string = "hello, world!";
@@ -69,10 +69,10 @@ void test_AND_op_node_evaluation() {
 }
 
 void test_OR_op_node_evaluation() {
-    auto child_expr1 = make_expr(&test_fixture::some_string, op::equals, std::string("hello, world!"));
-    auto child_expr2 = make_expr(&test_fixture::some_uint, op::less_than, (uint16_t) 500);
-
-    auto expr = make_op_node<test_fixture>(child_expr1, node::boolean_op::OR, child_expr2);
+    auto expr = std::unique_ptr<node::expression_tree_node<test_fixture>>(
+        make_expr(&test_fixture::some_string, op::equals, std::string("hello, world!"))
+        ->OR(make_expr(&test_fixture::some_uint, op::less_than, (uint16_t) 500))
+    );
 
     test_fixture fixture;
     fixture.some_string = "hello, world!";

tests/test_utils.hpp

@@ -15,15 +15,4 @@ struct test_fixture {
     bool is_some_uint_greater_than_zero() const {
         return some_uint;
     }
-};
-
-/**
- * Helper function for creating inner expression tree nodes. I'm undecided if this should be included in the public API.
-*/
-template<typename Obj, typename LeftChild, typename RightChild>
-std::unique_ptr<et::node::expression_tree_node<Obj>> make_op_node(LeftChild* left, et::node::boolean_op op, RightChild* right) {
-    auto node = new et::node::expression_tree_op_node<Obj, LeftChild, RightChild>(op);
-    node->set_left(left);
-    node->set_right(right);
-    return std::unique_ptr<et::node::expression_tree_node<Obj>>(node);
-}
+};