More work on DataTree query

Author: kunitoki

modules/yup_data_model/tree/yup_DataTreeQuery.cpp

@@ -39,6 +39,10 @@ struct DataTreeQuery::XPathParser
             AtSign,       // @
             Equal,        // =
             NotEqual,     // !=
+            Greater,      // >
+            Less,         // <
+            GreaterEqual, // >=
+            LessEqual,    // <=
             String,       // 'value' or "value"
             Number,       // 123, 45.67
             And,          // and
@@ -83,6 +87,10 @@ struct DataTreeQuery::XPathParser
             HasProperty,       // [@prop]
             PropertyEquals,    // [@prop='value']
             PropertyNotEquals, // [@prop!='value']
+            PropertyGreater,   // [@prop > value]
+            PropertyLess,      // [@prop < value]
+            PropertyGreaterEqual, // [@prop >= value]
+            PropertyLessEqual, // [@prop <= value]
             Position,          // [1], [2], etc.
             First,             // [first()]
             Last,              // [last()]
@@ -246,6 +254,22 @@ struct DataTreeQuery::XPathParser
 
             return; // Property selection terminates node traversal
         }
+        else if (token.type == Token::Type::Function && token.value == "text")
+        {
+            // text() function - select text property
+            ++currentToken;
+            
+            // Skip parentheses for text()
+            if (currentToken < static_cast<int> (tokens.size()) && tokens[currentToken].type == Token::Type::OpenParen)
+            {
+                ++currentToken;
+                if (currentToken < static_cast<int> (tokens.size()) && tokens[currentToken].type == Token::Type::CloseParen)
+                    ++currentToken;
+            }
+            
+            operations.emplace_back (QueryOperation::Property, "text");
+            return; // text() selection terminates node traversal
+        }
         else if (token.type == Token::Type::OpenBracket)
         {
             // Unexpected bracket without node test
@@ -424,6 +448,50 @@ struct DataTreeQuery::XPathParser
                         }
                         return std::make_unique<Predicate> (Predicate::PropertyNotEquals, propertyName, value);
                     }
+                    else if (tokens[currentToken].type == Token::Type::Greater)
+                    {
+                        ++currentToken;
+                        auto value = parseValue();
+                        if (!isValidValue(value))
+                        {
+                            parseResult = Result::fail("Expected value after comparison operator");
+                            return nullptr;
+                        }
+                        return std::make_unique<Predicate> (Predicate::PropertyGreater, propertyName, value);
+                    }
+                    else if (tokens[currentToken].type == Token::Type::Less)
+                    {
+                        ++currentToken;
+                        auto value = parseValue();
+                        if (!isValidValue(value))
+                        {
+                            parseResult = Result::fail("Expected value after comparison operator");
+                            return nullptr;
+                        }
+                        return std::make_unique<Predicate> (Predicate::PropertyLess, propertyName, value);
+                    }
+                    else if (tokens[currentToken].type == Token::Type::GreaterEqual)
+                    {
+                        ++currentToken;
+                        auto value = parseValue();
+                        if (!isValidValue(value))
+                        {
+                            parseResult = Result::fail("Expected value after comparison operator");
+                            return nullptr;
+                        }
+                        return std::make_unique<Predicate> (Predicate::PropertyGreaterEqual, propertyName, value);
+                    }
+                    else if (tokens[currentToken].type == Token::Type::LessEqual)
+                    {
+                        ++currentToken;
+                        auto value = parseValue();
+                        if (!isValidValue(value))
+                        {
+                            parseResult = Result::fail("Expected value after comparison operator");
+                            return nullptr;
+                        }
+                        return std::make_unique<Predicate> (Predicate::PropertyLessEqual, propertyName, value);
+                    }
                 }
 
                 // Just checking for property existence
@@ -489,13 +557,15 @@ struct DataTreeQuery::XPathParser
         QueryOperation op (QueryOperation::Where);
 
         auto predicatePtr = std::shared_ptr<Predicate> (std::move (predicate));
-        op.predicate = [predicatePtr] (const DataTree& node) -> bool
-        {
-            return evaluatePredicate (*predicatePtr, node, 0, 1); // position and size will be set during execution
-        };
+        
+        // Store the predicate for position-aware evaluation
+        op.xpathPredicate = predicatePtr;
+        
         operations.push_back (std::move (op));
     }
 
+
+public:
     static bool evaluatePredicate (const Predicate& predicate, const DataTree& node, int position, int totalCount)
     {
         switch (predicate.type)
@@ -509,6 +579,26 @@ struct DataTreeQuery::XPathParser
             case Predicate::PropertyNotEquals:
                 return ! node.hasProperty (predicate.property) || node.getProperty (predicate.property) != predicate.value;
 
+            case Predicate::PropertyGreater:
+                if (!node.hasProperty (predicate.property))
+                    return false;
+                return node.getProperty (predicate.property) > predicate.value;
+
+            case Predicate::PropertyLess:
+                if (!node.hasProperty (predicate.property))
+                    return false;
+                return node.getProperty (predicate.property) < predicate.value;
+
+            case Predicate::PropertyGreaterEqual:
+                if (!node.hasProperty (predicate.property))
+                    return false;
+                return node.getProperty (predicate.property) >= predicate.value;
+
+            case Predicate::PropertyLessEqual:
+                if (!node.hasProperty (predicate.property))
+                    return false;
+                return node.getProperty (predicate.property) <= predicate.value;
+
             case Predicate::Position:
                 return position == predicate.position - 1; // XPath is 1-indexed
 
@@ -531,6 +621,7 @@ struct DataTreeQuery::XPathParser
         return false;
     }
 
+private:
     void tokenize()
     {
         pos = 0;
@@ -598,6 +689,32 @@ struct DataTreeQuery::XPathParser
                     }
                     break;
 
+                case '>':
+                    if (pos + 1 < input.length() && input[pos + 1] == '=')
+                    {
+                        tokens.emplace_back (Token::Type::GreaterEqual, tokenStart);
+                        pos += 2;
+                    }
+                    else
+                    {
+                        tokens.emplace_back (Token::Type::Greater, tokenStart);
+                        ++pos;
+                    }
+                    break;
+
+                case '<':
+                    if (pos + 1 < input.length() && input[pos + 1] == '=')
+                    {
+                        tokens.emplace_back (Token::Type::LessEqual, tokenStart);
+                        pos += 2;
+                    }
+                    else
+                    {
+                        tokens.emplace_back (Token::Type::Less, tokenStart);
+                        ++pos;
+                    }
+                    break;
+
                 case '(':
                     tokens.emplace_back (Token::Type::OpenParen, tokenStart);
                     ++pos;
@@ -683,7 +800,7 @@ struct DataTreeQuery::XPathParser
         else if (identifier == "not")
             tokens.emplace_back (Token::Type::Not, start);
 
-        else if (identifier == "first" || identifier == "last" || identifier == "position" || identifier == "count")
+        else if (identifier == "first" || identifier == "last" || identifier == "position" || identifier == "count" || identifier == "text")
             tokens.emplace_back (Token::Type::Function, identifier, start);
 
         else
@@ -1135,8 +1252,21 @@ std::vector<DataTree> DataTreeQuery::applyOperation (const QueryOperation& op, c
 
         case QueryOperation::Where:
         {
-            if (op.predicate)
+            if (op.xpathPredicate)
+            {
+                // XPath predicate with position information
+                auto predicate = std::static_pointer_cast<XPathParser::Predicate>(op.xpathPredicate);
+                int totalCount = static_cast<int>(input.size());
+                for (int i = 0; i < static_cast<int>(input.size()); ++i)
+                {
+                    const auto& node = input[i];
+                    if (XPathParser::evaluatePredicate(*predicate, node, i, totalCount))
+                        result.push_back (node);
+                }
+            }
+            else if (op.predicate)
             {
+                // Regular predicate (from fluent API)
                 for (const auto& node : input)
                 {
                     if (op.predicate (node))

modules/yup_data_model/tree/yup_DataTreeQuery.h

@@ -22,16 +22,6 @@
 namespace yup
 {
 
-//==============================================================================
-// Forward declaration for VarHasher
-struct VarHasher
-{
-    std::size_t operator() (const var& v) const
-    {
-        return std::hash<String>() (v.toString());
-    }
-};
-
 //==============================================================================
 /**
     A powerful query system for extracting data from DataTree hierarchies using both fluent API and XPath-like syntax.
@@ -111,6 +101,15 @@ struct VarHasher
 */
 class YUP_API DataTreeQuery
 {
+    //==============================================================================
+    struct VarHasher
+    {
+        std::size_t operator() (const var& v) const
+        {
+            return std::hash<String>() (v.toString());
+        }
+    };
+
 public:
     //==============================================================================
     /**
@@ -428,6 +427,9 @@ class YUP_API DataTreeQuery
         var parameter2;
         std::function<bool (const DataTree&)> predicate;
         std::function<var (const DataTree&)> transformer;
+        
+        // For XPath predicates that need position information
+        std::shared_ptr<void> xpathPredicate;
 
         QueryOperation (Type t)
             : type (t)
@@ -539,7 +541,7 @@ DataTreeQuery& DataTreeQuery::orderBy (KeySelector keySelector)
 }
 
 template <typename KeySelector>
-std::unordered_map<var, std::vector<DataTree>, VarHasher> DataTreeQuery::groupBy (KeySelector keySelector) const
+std::unordered_map<var, std::vector<DataTree>, DataTreeQuery::VarHasher> DataTreeQuery::groupBy (KeySelector keySelector) const
 {
     auto results = nodes();
     std::unordered_map<var, std::vector<DataTree>, VarHasher> groups;

tests/yup_data_model/yup_DataTreeQuery.cpp

@@ -917,11 +917,11 @@ TEST_F (DataTreeQueryTests, XPathInvalidSyntax)
 
 TEST_F (DataTreeQueryTests, XPathComplexExpressions)
 {
-    // Complex boolean expressions
+    // Complex boolean expressions with AND and comparison operators
     auto result = DataTreeQuery::xpath (testTree, "//Button[@enabled='true' and @width > 50]").nodes();
     EXPECT_GT (static_cast<int> (result.size()), 0);
 
-    // OR expressions
+    // OR expressions with comparison operators
     auto result2 = DataTreeQuery::xpath (testTree, "//Button[@width > 100 or @enabled='false']").nodes();
     EXPECT_GT (static_cast<int> (result2.size()), 0);