Address review comments.

gibber9809 · gibber9809 · commit 72bfe06ad2d3 · 2025-08-04T18:57:44.000-04:00
diff --git a/components/core/src/clp/GrepCore.hpp b/components/core/src/clp/GrepCore.hpp
@@ -31,7 +31,7 @@ class GrepCore {
      *
      * @tparam LogTypeDictionaryReaderType
      * @tparam VariableDictionaryReaderType
-     * @param log_dict
+     * @param logtype_dict
      * @param var_dict
      * @param search_string
      * @param search_begin_ts
@@ -43,7 +43,7 @@ class GrepCore {
      */
     template <typename LogTypeDictionaryReaderType, typename VariableDictionaryReaderType>
     static std::optional<Query> process_raw_query(
-            LogTypeDictionaryReaderType const& log_dict,
+            LogTypeDictionaryReaderType const& logtype_dict,
             VariableDictionaryReaderType const& var_dict,
             std::string const& search_string,
             epochtime_t search_begin_ts,
@@ -120,7 +120,7 @@ class GrepCore {
      * @tparam LogTypeDictionaryReaderType
      * @tparam VariableDictionaryReaderType
      * @tparam LogTypeDictionaryEntryType
-     * @param log_dict
+     * @param logtype_dict
      * @param var_dict
      * @param processed_search_string
      * @param query_tokens
@@ -135,7 +135,7 @@ class GrepCore {
             typename VariableDictionaryReaderType,
             typename LogTypeDictionaryEntryType = typename LogTypeDictionaryReaderType::entry_t>
     static SubQueryMatchabilityResult generate_logtypes_and_vars_for_subquery(
-            LogTypeDictionaryReaderType const& log_dict,
+            LogTypeDictionaryReaderType const& logtype_dict,
             VariableDictionaryReaderType const& var_dict,
             std::string& processed_search_string,
             std::vector<QueryToken>& query_tokens,
@@ -146,7 +146,7 @@ class GrepCore {
 
 template <typename LogTypeDictionaryReaderType, typename VariableDictionaryReaderType>
 std::optional<Query> GrepCore::process_raw_query(
-        LogTypeDictionaryReaderType const& log_dict,
+        LogTypeDictionaryReaderType const& logtype_dict,
         VariableDictionaryReaderType const& var_dict,
         std::string const& search_string,
         epochtime_t search_begin_ts,
@@ -220,7 +220,7 @@ std::optional<Query> GrepCore::process_raw_query(
 
         // Compute logtypes and variables for query
         auto matchability = generate_logtypes_and_vars_for_subquery(
-                log_dict,
+                logtype_dict,
                 var_dict,
                 search_string_for_sub_queries,
                 query_tokens,
@@ -330,7 +330,7 @@ template <
         typename VariableDictionaryReaderType,
         typename LogTypeDictionaryEntryType>
 GrepCore::SubQueryMatchabilityResult GrepCore::generate_logtypes_and_vars_for_subquery(
-        LogTypeDictionaryReaderType const& log_dict,
+        LogTypeDictionaryReaderType const& logtype_dict,
         VariableDictionaryReaderType const& var_dict,
         std::string& processed_search_string,
         std::vector<QueryToken>& query_tokens,
@@ -406,7 +406,7 @@ GrepCore::SubQueryMatchabilityResult GrepCore::generate_logtypes_and_vars_for_su
 
     // Find matching logtypes
     std::unordered_set<LogTypeDictionaryEntryType const*> possible_logtype_entries;
-    log_dict.get_entries_matching_wildcard_string(logtype, ignore_case, possible_logtype_entries);
+    logtype_dict.get_entries_matching_wildcard_string(logtype, ignore_case, possible_logtype_entries);
     if (possible_logtype_entries.empty()) {
         return SubQueryMatchabilityResult::WontMatch;
     }
diff --git a/components/core/src/clp/Query.cpp b/components/core/src/clp/Query.cpp
@@ -70,7 +70,7 @@ bool QueryVar::matches(encoded_variable_t var) const {
 
 void QueryVar::remove_segments_that_dont_contain_dict_var(
         set<segment_id_t>& segment_ids,
-        std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)>
+        std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)> const&
                 get_segments_containing_var_dict_id
 ) const {
     if (false == m_is_dict_var) {
@@ -84,8 +84,8 @@ void QueryVar::remove_segments_that_dont_contain_dict_var(
         inplace_set_intersection(ids_of_segments_containing_query_var, segment_ids);
     } else {
         set<segment_id_t> ids_of_segments_containing_query_var;
-        for (auto entry : m_possible_var_dict_ids) {
-            auto& ids_of_segments_containing_var = get_segments_containing_var_dict_id(entry);
+        for (auto var_dict_id : m_possible_var_dict_ids) {
+            auto& ids_of_segments_containing_var = get_segments_containing_var_dict_id(var_dict_id);
             ids_of_segments_containing_query_var.insert(
                     ids_of_segments_containing_var.cbegin(),
                     ids_of_segments_containing_var.cend()
@@ -112,24 +112,24 @@ void SubQuery::add_imprecise_dict_var(
 }
 
 void SubQuery::set_possible_logtypes(unordered_set<logtype_dictionary_id_t> const& logtype_ids) {
-    m_possible_logtype_ids = logtype_ids;
+    m_possible_logtypes = logtype_ids;
 }
 
 void SubQuery::mark_wildcard_match_required() {
     m_wildcard_match_required = true;
 }
 
 void SubQuery::calculate_ids_of_matching_segments(
-        std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)>
-                get_segments_containing_log_dict_id,
-        std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)>
+        std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)> const&
+                get_segments_containing_logtype_dict_id,
+        std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)> const&
                 get_segments_containing_var_dict_id
 ) {
     // Get IDs of segments containing logtypes
     m_ids_of_matching_segments.clear();
-    for (auto logtype_id : m_possible_logtype_ids) {
+    for (auto logtype_id : m_possible_logtypes) {
         auto const& ids_of_segments_containing_logtype
-                = get_segments_containing_log_dict_id(logtype_id);
+                = get_segments_containing_logtype_dict_id(logtype_id);
         m_ids_of_matching_segments.insert(
                 ids_of_segments_containing_logtype.cbegin(),
                 ids_of_segments_containing_logtype.cend()
@@ -147,12 +147,12 @@ void SubQuery::calculate_ids_of_matching_segments(
 
 void SubQuery::clear() {
     m_vars.clear();
-    m_possible_logtype_ids.clear();
+    m_possible_logtypes.clear();
     m_wildcard_match_required = false;
 }
 
 bool SubQuery::matches_logtype(logtype_dictionary_id_t const logtype) const {
-    return m_possible_logtype_ids.count(logtype) > 0;
+    return m_possible_logtypes.count(logtype) > 0;
 }
 
 Query::Query(
@@ -187,14 +187,14 @@ void Query::make_sub_queries_relevant_to_segment(segment_id_t segment_id) {
 }
 
 void Query::calculate_ids_of_matching_segments(
-        std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)>
-                get_segments_containing_log_dict_id,
-        std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)>
+        std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)> const&
+                get_segments_containing_logtype_dict_id,
+        std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)> const&
                 get_segments_containing_var_dict_id
 ) {
     for (auto& sub_query : m_sub_queries) {
         sub_query.calculate_ids_of_matching_segments(
-                get_segments_containing_log_dict_id,
+                get_segments_containing_logtype_dict_id,
                 get_segments_containing_var_dict_id
         );
     }
diff --git a/components/core/src/clp/Query.hpp b/components/core/src/clp/Query.hpp
@@ -39,7 +39,7 @@ class QueryVar {
      */
     void remove_segments_that_dont_contain_dict_var(
             std::set<segment_id_t>& segment_ids,
-            std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)>
+            std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)> const&
                     get_segments_containing_var_dict_id
     ) const;
 
@@ -106,24 +106,24 @@ class SubQuery {
     /**
      * Calculates the segment IDs that should contain a match for the subquery's current logtypes
      * and QueryVars.
-     * @param get_segments_containing_log_dict_id
+     * @param get_segments_containing_logtype_dict_id
      * @param get_segments_containing_var_dict_id
      */
     void calculate_ids_of_matching_segments(
-            std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)>
-                    get_segments_containing_log_dict_id,
-            std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)>
+            std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)> const&
+                    get_segments_containing_logtype_dict_id,
+            std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)> const&
                     get_segments_containing_var_dict_id
     );
 
     void clear();
 
     bool wildcard_match_required() const { return m_wildcard_match_required; }
 
-    size_t get_num_possible_logtypes() const { return m_possible_logtype_ids.size(); }
+    size_t get_num_possible_logtypes() const { return m_possible_logtypes.size(); }
 
     std::unordered_set<logtype_dictionary_id_t> const& get_possible_logtypes() const {
-        return m_possible_logtype_ids;
+        return m_possible_logtypes;
     }
 
     size_t get_num_possible_vars() const { return m_vars.size(); }
@@ -152,7 +152,7 @@ class SubQuery {
 
 private:
     // Variables
-    std::unordered_set<logtype_dictionary_id_t> m_possible_logtype_ids;
+    std::unordered_set<logtype_dictionary_id_t> m_possible_logtypes;
     std::set<segment_id_t> m_ids_of_matching_segments;
     std::vector<QueryVar> m_vars;
     bool m_wildcard_match_required;
@@ -213,13 +213,13 @@ class Query {
     /**
      * Calculates the segment IDs that should contain a match for each subquery's logtypes and
      * QueryVars.
-     * @param get_segments_containing_log_dict_id
+     * @param get_segments_containing_logtype_dict_id
      * @param get_segments_containing_var_dict_id
      */
     void calculate_ids_of_matching_segments(
-            std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)>
-                    get_segments_containing_log_dict_id,
-            std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)>
+            std::function<std::set<segment_id_t> const&(logtype_dictionary_id_t)> const&
+                    get_segments_containing_logtype_dict_id,
+            std::function<std::set<segment_id_t> const&(variable_dictionary_id_t)> const&
                     get_segments_containing_var_dict_id
     );
 
diff --git a/components/core/src/clp/QueryToken.hpp b/components/core/src/clp/QueryToken.hpp
@@ -56,7 +56,7 @@ class QueryToken {
     std::string m_value;
 
     // Type if variable has unambiguous type
-    Type m_type{};
+    Type m_type{Type::Wildcard};
     // Types if variable type is ambiguous
     std::vector<Type> m_possible_types;
     // Index of the current possible type selected for generating a subquery
diff --git a/components/core/src/clp/StringReader.cpp b/components/core/src/clp/StringReader.cpp
@@ -7,6 +7,8 @@
 #include <cassert>
 #include <cerrno>
 
+#include <boost/filesystem.hpp>
+
 using std::string;
 
 namespace clp {
diff --git a/components/core/src/clp/clg/clg.cpp b/components/core/src/clp/clg/clg.cpp
@@ -212,10 +212,10 @@ static bool search(
         std::set<segment_id_t> ids_of_segments_to_search;
         bool is_superseding_query = false;
         for (auto const& search_string : search_strings) {
-            auto const& log_dict{archive.get_logtype_dictionary()};
+            auto const& logtype_dict{archive.get_logtype_dictionary()};
             auto const& var_dict{archive.get_var_dictionary()};
             auto query_processing_result = GrepCore::process_raw_query(
-                    log_dict,
+                    logtype_dict,
                     var_dict,
                     search_string,
                     search_begin_ts,
@@ -240,19 +240,19 @@ static bool search(
                 }
 
                 // Calculate the IDs of the segments that may contain results for each sub-query.
-                auto get_segments_containing_log_dict_id
-                        = [&log_dict](
+                auto get_segments_containing_logtype_dict_id
+                        = [&logtype_dict](
                                   logtype_dictionary_id_t logtype_id
                           ) -> std::set<segment_id_t> const& {
-                    return log_dict.get_entry(logtype_id).get_ids_of_segments_containing_entry();
+                    return logtype_dict.get_entry(logtype_id).get_ids_of_segments_containing_entry();
                 };
                 auto get_segments_containing_var_dict_id = [&var_dict](
                                                                    variable_dictionary_id_t var_id
                                                            ) -> std::set<segment_id_t> const& {
                     return var_dict.get_entry(var_id).get_ids_of_segments_containing_entry();
                 };
                 query.calculate_ids_of_matching_segments(
-                        get_segments_containing_log_dict_id,
+                        get_segments_containing_logtype_dict_id,
                         get_segments_containing_var_dict_id
                 );
 
diff --git a/components/core/src/clp/clo/CMakeLists.txt b/components/core/src/clp/clo/CMakeLists.txt
@@ -59,10 +59,10 @@ set(
         ../Platform.hpp
         ../Profiler.cpp
         ../Profiler.hpp
-        ../QueryToken.cpp
-        ../QueryToken.hpp
         ../Query.cpp
         ../Query.hpp
+        ../QueryToken.cpp
+        ../QueryToken.hpp
         ../ReaderInterface.cpp
         ../ReaderInterface.hpp
         ../ReadOnlyMemoryMappedFile.cpp
diff --git a/components/core/src/clp/clo/clo.cpp b/components/core/src/clp/clo/clo.cpp
@@ -497,13 +497,13 @@ static bool search_archive(
 
     auto search_begin_ts = command_line_args.get_search_begin_ts();
     auto search_end_ts = command_line_args.get_search_end_ts();
-    auto const& log_dict{archive_reader.get_logtype_dictionary()};
+    auto const& logtype_dict{archive_reader.get_logtype_dictionary()};
     auto const& var_dict{archive_reader.get_var_dictionary()};
 
     std::string wildcard_search_string
             = clean_up_wildcard_search_string('*' + command_line_args.get_search_string() + '*');
     auto query_processing_result = GrepCore::process_raw_query(
-            log_dict,
+            logtype_dict,
             var_dict,
             wildcard_search_string,
             search_begin_ts,
@@ -518,16 +518,16 @@ static bool search_archive(
 
     auto& query = query_processing_result.value();
     // Calculate the IDs of the segments that may contain results for each sub-query.
-    auto get_segments_containing_log_dict_id
-            = [&log_dict](logtype_dictionary_id_t logtype_id) -> std::set<segment_id_t> const& {
-        return log_dict.get_entry(logtype_id).get_ids_of_segments_containing_entry();
+    auto get_segments_containing_logtype_dict_id
+            = [&logtype_dict](logtype_dictionary_id_t logtype_id) -> std::set<segment_id_t> const& {
+        return logtype_dict.get_entry(logtype_id).get_ids_of_segments_containing_entry();
     };
     auto get_segments_containing_var_dict_id
             = [&var_dict](variable_dictionary_id_t var_id) -> std::set<segment_id_t> const& {
         return var_dict.get_entry(var_id).get_ids_of_segments_containing_entry();
     };
     query.calculate_ids_of_matching_segments(
-            get_segments_containing_log_dict_id,
+            get_segments_containing_logtype_dict_id,
             get_segments_containing_var_dict_id
     );
 
