feat: Add Query class to compute QueryInterpretations from a user specified query.

CMakeLists.txt

@@ -88,6 +88,8 @@ set(SOURCE_FILES
     src/log_surgeon/wildcard_query_parser/ExpressionCharacter.hpp
     src/log_surgeon/wildcard_query_parser/ExpressionView.cpp
     src/log_surgeon/wildcard_query_parser/ExpressionView.hpp
+    src/log_surgeon/wildcard_query_parser/Query.cpp
+    src/log_surgeon/wildcard_query_parser/Query.hpp
     src/log_surgeon/wildcard_query_parser/QueryInterpretation.cpp
     src/log_surgeon/wildcard_query_parser/QueryInterpretation.hpp
     src/log_surgeon/wildcard_query_parser/StaticQueryToken.hpp

docs/doxygen/mainpage.dox

@@ -17,6 +17,7 @@
  * - @ref unit_tests_expression_view "Expression View"
  * - @ref unit_tests_nfa "NFA"
  * - @ref unit_tests_prefix_tree "Prefix tree"
+ * - @ref unit_tests_query "Query"
  * - @ref unit_tests_query_interpretation "Query Interpretation"
  * - @ref unit_tests_regex_ast "Regex AST"
  * - @ref unit_tests_register_handler "Register handler"

src/log_surgeon/Lexer.hpp

@@ -152,6 +152,10 @@ class Lexer {
 
     [[nodiscard]] auto get_has_delimiters() const -> bool const& { return m_has_delimiters; }
 
+    [[nodiscard]] auto get_delim_table() const -> std::array<bool, cSizeOfByte> const& {
+        return m_is_delimiter;
+    }
+
     [[nodiscard]] auto is_delimiter(uint8_t byte) const -> bool const& {
         return m_is_delimiter[byte];
     }
@@ -252,7 +256,10 @@ class Lexer {
     std::array<bool, cSizeOfByte> m_is_first_char_of_a_variable{false};
     std::vector<LexicalRule<TypedNfaState>> m_rules;
     uint32_t m_line{0};
+
+    // For performance, `m_has_delimiters` caches whether any element in `m_is_delimiter` is true.
     bool m_has_delimiters{false};
+
     std::unique_ptr<finite_automata::Dfa<TypedDfaState, TypedNfaState>> m_dfa;
     std::optional<uint32_t> m_first_delimiter_pos{std::nullopt};
     bool m_asked_for_more_data{false};

src/log_surgeon/wildcard_query_parser/Expression.hpp

@@ -1,6 +1,7 @@
 #ifndef LOG_SURGEON_WILDCARD_QUERY_PARSER_EXPRESSION_HPP
 #define LOG_SURGEON_WILDCARD_QUERY_PARSER_EXPRESSION_HPP
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -24,6 +25,8 @@ class Expression {
 
     [[nodiscard]] auto get_search_string() const -> std::string const& { return m_search_string; }
 
+    [[nodiscard]] auto length() const -> size_t { return m_search_string.size(); }
+
 private:
     std::vector<ExpressionCharacter> m_chars;
     std::string m_search_string;

src/log_surgeon/wildcard_query_parser/ExpressionCharacter.hpp

@@ -1,8 +1,11 @@
 #ifndef LOG_SURGEON_WILDCARD_QUERY_PARSER_EXPRESSION_CHARACTER_HPP
 #define LOG_SURGEON_WILDCARD_QUERY_PARSER_EXPRESSION_CHARACTER_HPP
 
+#include <array>
 #include <cstdint>
 
+#include <log_surgeon/Constants.hpp>
+
 namespace log_surgeon::wildcard_query_parser {
 class ExpressionCharacter {
 public:
@@ -23,6 +26,19 @@ class ExpressionCharacter {
         return Type::NonGreedyWildcard == m_type;
     }
 
+    [[nodiscard]] auto is_wildcard() const -> bool {
+        return Type::GreedyWildcard == m_type || Type::NonGreedyWildcard == m_type;
+    }
+
+    [[nodiscard]] auto is_delim(std::array<bool, cSizeOfByte> const& delim_table) const -> bool {
+        return delim_table.at(static_cast<uint8_t>(m_value));
+    }
+
+    [[nodiscard]] auto is_delim_or_wildcard(std::array<bool, cSizeOfByte> const& delim_table) const
+            -> bool {
+        return is_delim(delim_table) || is_wildcard();
+    }
+
     [[nodiscard]] auto is_escape() const -> bool { return Type::Escape == m_type; }
 
 private:

src/log_surgeon/wildcard_query_parser/ExpressionView.cpp

@@ -1,12 +1,14 @@
 #include "ExpressionView.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cstddef>
 #include <span>
 #include <string>
 #include <string_view>
 #include <utility>
 
+#include <log_surgeon/Constants.hpp>
 #include <log_surgeon/SchemaParser.hpp>
 #include <log_surgeon/wildcard_query_parser/Expression.hpp>
 
@@ -42,6 +44,39 @@ auto ExpressionView::extend_to_adjacent_greedy_wildcards() const
     return {is_extended, wildcard_expression_view};
 }
 
+auto ExpressionView::is_surrounded_by_delims(std::array<bool, cSizeOfByte> const& delim_table) const
+        -> bool {
+    auto const [begin_idx, end_idx]{get_indices()};
+
+    bool has_left_boundary{false};
+    if (0 == begin_idx) {
+        has_left_boundary = true;
+    } else {
+        auto const& preceding_char{m_expression->get_chars()[begin_idx - 1]};
+        has_left_boundary = preceding_char.is_delim_or_wildcard(delim_table)
+                            || (false == m_chars.empty() && m_chars.front().is_greedy_wildcard());
+    }
+
+    bool has_right_boundary{false};
+    if (m_expression->length() == end_idx) {
+        has_right_boundary = true;
+    } else {
+        auto const& succeeding_char{m_expression->get_chars()[end_idx]};
+        if (succeeding_char.is_escape()) {
+            if (m_expression->length() > end_idx + 1) {
+                auto const& logical_succeeding_char{m_expression->get_chars()[end_idx + 1]};
+                has_right_boundary = logical_succeeding_char.is_delim(delim_table);
+            }
+        } else {
+            has_right_boundary = succeeding_char.is_delim_or_wildcard(delim_table);
+        }
+        has_right_boundary = has_right_boundary
+                             || (false == m_chars.empty() && m_chars.back().is_greedy_wildcard());
+    }
+
+    return has_left_boundary && has_right_boundary;
+}
+
 auto ExpressionView::is_well_formed() const -> bool {
     if (m_chars.empty()) {
         return true;

src/log_surgeon/wildcard_query_parser/ExpressionView.hpp

@@ -1,12 +1,14 @@
 #ifndef LOG_SURGEON_WILDCARD_QUERY_PARSER_EXPRESSION_VIEW_HPP
 #define LOG_SURGEON_WILDCARD_QUERY_PARSER_EXPRESSION_VIEW_HPP
 
+#include <array>
 #include <cstddef>
 #include <span>
 #include <string>
 #include <string_view>
 #include <utility>
 
+#include <log_surgeon/Constants.hpp>
 #include <log_surgeon/wildcard_query_parser/Expression.hpp>
 #include <log_surgeon/wildcard_query_parser/ExpressionCharacter.hpp>
 
@@ -41,6 +43,33 @@ class ExpressionView {
                && (m_chars[0].is_greedy_wildcard() || m_chars.back().is_greedy_wildcard());
     }
 
+    /**
+     * Checks whether the view is surrounded by delimiters. The start and end of an expression are
+     * always considered a delimiter. A greedy wildcard may represent a string that includes a
+     * flanking delimiter.
+     *
+     * A view is considered bounded if both its left and right boundary satisfy certain
+     * requirements.
+     *
+     * Left boundary:
+     * - The view is at the start of the expression, or
+     * - The first character is a greedy wildcard (if non-empty), or
+     * - Immediately left of the view is a delimiter or wildcard.
+     *
+     * Right boundary:
+     * - The view is at the end of the expression, or
+     * - The last character is a greedy wildcard (if non-empty), or
+     * - Immediately right of the view is a delimiter or wildcard, or
+     * - Immediately right of the view is an escape character and the character to its
+     *   immediate right is a delimiter.
+     *
+     * @param delim_table Table indicating for each character whether or not it is a delimiter.
+     * @return true when both left and right boundaries qualify; false otherwise.
+     */
+    [[nodiscard]] auto is_surrounded_by_delims(
+            std::array<bool, cSizeOfByte> const& delim_table
+    ) const -> bool;
+
     /**
      * Checks whether this `ExpressionView` represents a well-formed subrange.
      *

src/log_surgeon/wildcard_query_parser/Query.cpp

@@ -0,0 +1,176 @@
+#include "Query.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <log_surgeon/finite_automata/Dfa.hpp>
+#include <log_surgeon/finite_automata/DfaState.hpp>
+#include <log_surgeon/finite_automata/Nfa.hpp>
+#include <log_surgeon/finite_automata/NfaState.hpp>
+#include <log_surgeon/Lexer.hpp>
+#include <log_surgeon/LexicalRule.hpp>
+#include <log_surgeon/parser_types.hpp>
+#include <log_surgeon/Schema.hpp>
+#include <log_surgeon/SchemaParser.hpp>
+#include <log_surgeon/wildcard_query_parser/Expression.hpp>
+#include <log_surgeon/wildcard_query_parser/ExpressionView.hpp>
+#include <log_surgeon/wildcard_query_parser/QueryInterpretation.hpp>
+
+using log_surgeon::finite_automata::ByteDfaState;
+using log_surgeon::finite_automata::ByteNfaState;
+using log_surgeon::lexers::ByteLexer;
+using std::set;
+using std::string;
+using std::vector;
+
+using ByteDfa = log_surgeon::finite_automata::Dfa<ByteDfaState, ByteNfaState>;
+using ByteLexicalRule = log_surgeon::LexicalRule<ByteNfaState>;
+using ByteNfa = log_surgeon::finite_automata::Nfa<ByteNfaState>;
+
+namespace log_surgeon::wildcard_query_parser {
+Query::Query(string const& query_string) {
+    m_processed_query_string.reserve(query_string.size());
+    Expression const expression(query_string);
+
+    bool prev_is_escape{false};
+    string unhandled_wildcard_sequence;
+    bool unhandled_wildcard_sequence_contains_greedy_wildcard{false};
+    for (auto c : expression.get_chars()) {
+        if (false == unhandled_wildcard_sequence.empty() && false == c.is_wildcard()) {
+            if (unhandled_wildcard_sequence_contains_greedy_wildcard) {
+                m_processed_query_string.push_back('*');
+            } else {
+                m_processed_query_string += unhandled_wildcard_sequence;
+            }
+            unhandled_wildcard_sequence.clear();
+            unhandled_wildcard_sequence_contains_greedy_wildcard = false;
+        }
+
+        if (prev_is_escape) {
+            m_processed_query_string.push_back(c.value());
+            prev_is_escape = false;
+        } else if (c.is_escape()) {
+            prev_is_escape = true;
+            m_processed_query_string.push_back(c.value());
+        } else if (c.is_greedy_wildcard()) {
+            unhandled_wildcard_sequence.push_back(c.value());
+            unhandled_wildcard_sequence_contains_greedy_wildcard = true;
+        } else if (c.is_non_greedy_wildcard()) {
+            unhandled_wildcard_sequence.push_back(c.value());
+        } else {
+            m_processed_query_string.push_back(c.value());
+        }
+    }
+    if (false == unhandled_wildcard_sequence.empty()) {
+        if (unhandled_wildcard_sequence_contains_greedy_wildcard) {
+            m_processed_query_string.push_back('*');
+        } else {
+            m_processed_query_string += unhandled_wildcard_sequence;
+        }
+    }
+}
+
+auto Query::get_all_multi_token_interpretations(ByteLexer const& lexer) const
+        -> std::set<QueryInterpretation> {
+    if (m_processed_query_string.empty()) {
+        return {};
+    }
+
+    Expression const expression{m_processed_query_string};
+    vector<set<QueryInterpretation>> query_interpretations(expression.length());
+    for (size_t end_idx = 1; end_idx <= expression.length(); ++end_idx) {
+        for (size_t begin_idx = 0; begin_idx < end_idx; ++begin_idx) {
+            ExpressionView const expression_view{expression, begin_idx, end_idx};
+            if ("*" != expression_view.get_search_string()
+                && expression_view.starts_or_ends_with_greedy_wildcard())
+            {
+                continue;
+            }
+
+            auto const extended_view{expression_view.extend_to_adjacent_greedy_wildcards().second};
+            auto const single_token_interpretations{
+                    get_all_single_token_interpretations(extended_view, lexer)
+            };
+            if (single_token_interpretations.empty()) {
+                continue;
+            }
+
+            if (begin_idx == 0) {
+                query_interpretations[end_idx - 1].insert(
+                        std::make_move_iterator(single_token_interpretations.begin()),
+                        std::make_move_iterator(single_token_interpretations.end())
+                );
+            } else {
+                for (auto const& prefix : query_interpretations[begin_idx - 1]) {
+                    for (auto const& suffix : single_token_interpretations) {
+                        QueryInterpretation combined{prefix};
+                        combined.append_query_interpretation(suffix);
+                        query_interpretations[end_idx - 1].insert(std::move(combined));
+                    }
+                }
+            }
+        }
+    }
+    return query_interpretations.back();
+}
+
+auto Query::get_all_single_token_interpretations(
+        ExpressionView const& expression_view,
+        ByteLexer const& lexer
+) -> std::vector<QueryInterpretation> {
+    vector<QueryInterpretation> interpretations;
+
+    if (false == expression_view.is_well_formed()) {
+        return interpretations;
+    }
+    if ("*" == expression_view.get_search_string()) {
+        interpretations.emplace_back("*");
+        return interpretations;
+    }
+    if (false == expression_view.is_surrounded_by_delims(lexer.get_delim_table())) {
+        interpretations.emplace_back(string{expression_view.get_search_string()});
+        return interpretations;
+    }
+
+    auto const [regex_string, contains_wildcard]{expression_view.generate_regex_string()};
+
+    auto const matching_var_type_ids{get_matching_variable_types(regex_string, lexer)};
+    if (matching_var_type_ids.empty() || contains_wildcard) {
+        interpretations.emplace_back(string{expression_view.get_search_string()});
+    }
+
+    for (auto const variable_type_id : matching_var_type_ids) {
+        interpretations.emplace_back(
+                variable_type_id,
+                string{expression_view.get_search_string()},
+                contains_wildcard
+        );
+        if (false == contains_wildcard) {
+            break;
+        }
+    }
+    return interpretations;
+}
+
+auto Query::get_matching_variable_types(string const& regex_string, ByteLexer const& lexer)
+        -> set<uint32_t> {
+    NonTerminal::m_next_children_start = 0;
+
+    Schema schema;
+    schema.add_variable("search:" + regex_string, -1);
+    auto const schema_ast = schema.release_schema_ast_ptr();
+    auto& rule_ast = dynamic_cast<SchemaVarAST&>(*schema_ast->m_schema_vars[0]);
+    vector<ByteLexicalRule> rules;
+    rules.emplace_back(0, std::move(rule_ast.m_regex_ptr));
+    ByteNfa const nfa{rules};
+    ByteDfa const dfa{nfa};
+
+    auto var_types = lexer.get_dfa()->get_intersect(&dfa);
+    return var_types;
+}
+}  // namespace log_surgeon::wildcard_query_parser