Add [[nodiscard]] attribute to relevant functions for better code cla…

…rity
jkurdek · Feb 8, 2025 · 95817dc · 95817dc
1 parent 35f7d38
commit 95817dc
Show file tree

Hide file tree

Showing 8 changed files with 24 additions and 24 deletions.
diff --git a/include/cascade_builder.h b/include/cascade_builder.h
@@ -12,7 +12,7 @@ class CascadeBuilder {
     CascadeBuilder(const PredicateDisjunction& disjunction, const RawFilterData& raw_filter_data)
         : disjunction_(disjunction), rf_data_(raw_filter_data) {}
 
-    std::vector<std::shared_ptr<Node>> GenerateValidCascades();
+    [[nodiscard]] std::vector<std::shared_ptr<Node>> GenerateValidCascades();
 
    private:
     std::shared_ptr<Node> fail_node = std::make_shared<Node>(0, 0, 0, nullptr, nullptr, NodeType::FAIL);
@@ -22,8 +22,9 @@ class CascadeBuilder {
     std::bitset<kMaxConj> used_conjunctions_;
     std::array<std::array<std::bitset<kMaxRfsInPred>, kMaxPred>, kMaxConj> used_rfs_;
 
-    std::vector<std::shared_ptr<Node>> HandleFail(const size_t current_depth);
-    std::vector<std::shared_ptr<Node>> HandleSuccess(const size_t current_depth, const size_t conjunction_idx);
+    [[nodiscard]] std::vector<std::shared_ptr<Node>> HandleFail(const size_t current_depth);
+    [[nodiscard]] std::vector<std::shared_ptr<Node>> HandleSuccess(const size_t current_depth,
+                                                                   const size_t conjunction_idx);
 };
 
 #endif  // CASCADE_BUILDER_H_
diff --git a/include/cascade_evaluator.h b/include/cascade_evaluator.h
@@ -18,7 +18,7 @@ class CascadeEvaluator {
    public:
     CascadeEvaluator(const EstimationResult& estimation_result) : estimation_result_(estimation_result) {}
 
-    double EvaluateCascade(std::shared_ptr<Node> cascade);
+    [[nodiscard]] double EvaluateCascade(std::shared_ptr<Node> cascade);
     std::array<double, kTotalMaxRfs + 2> rf_probabilities_;  // Changes every call to EvaluateCascade
     const size_t parse_idx_ = kTotalMaxRfs + 1;
     const size_t fail_idx_ = kTotalMaxRfs;

diff --git a/include/common.h b/include/common.h
@@ -5,9 +5,9 @@
 
 using bench_timer_t = std::chrono::time_point<std::chrono::steady_clock>;
 
-inline bench_timer_t benchmark_start() { return std::chrono::steady_clock::now(); }
+[[nodiscard]] inline bench_timer_t benchmark_start() { return std::chrono::steady_clock::now(); }
 
-inline double benchmark_stop(bench_timer_t start) {
+[[nodiscard]] inline double benchmark_stop(bench_timer_t start) {
     auto end = std::chrono::steady_clock::now();
     return std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1'000'000.0;
 }

diff --git a/include/input_reader.h b/include/input_reader.h
@@ -6,8 +6,8 @@
 
 class InputReader {
    public:
-    static std::string ReadFile(const std::string& filename);
-    static std::vector<std::string_view> ReadRecords(const std::string& input);
+    [[nodiscard]] static std::string ReadFile(const std::string& filename);
+    [[nodiscard]] static std::vector<std::string_view> ReadRecords(const std::string& input);
 };
 
 #endif  // INPUT_READER_H_
diff --git a/include/json_facade.h b/include/json_facade.h
@@ -1,14 +1,11 @@
 #ifndef JSON_FACADE_H_
 #define JSON_FACADE_H_
 
-#include <optional>
+#include <memory>
 #include <string>
 #include <string_view>
-#include <unordered_map>
 #include <vector>
 
-#include "rapidjson/document.h"
-
 struct Predicate {
     std::string key;
     std::string value;
@@ -38,18 +35,18 @@ class JsonQuery {
 class JsonFacade {
    public:
     virtual ~JsonFacade() = default;
-    virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) = 0;
+    [[nodiscard]] virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) = 0;
 };
 
 class RapidJsonFacade : public JsonFacade {
    public:
-    virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) override;
+    [[nodiscard]] virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) override;
 };
 
 class JsonQueryDriver {
    public:
     explicit JsonQueryDriver(std::unique_ptr<JsonFacade>&& json_facade = {}) : json_facade_(std::move(json_facade)) {}
-    bool RunQuery(std::string_view buffer, const JsonQuery& query);
+    [[nodiscard]] bool RunQuery(std::string_view buffer, const JsonQuery& query);
 
    private:
     std::unique_ptr<JsonFacade> json_facade_;

diff --git a/include/raw_filter.h b/include/raw_filter.h
@@ -16,11 +16,11 @@ struct RawFilterData {
 
 class RawFilterQueryGenerator {
    public:
-    static RawFilterData GenerateRawFilters(const PredicateDisjunction& disjunction);
-    static std::vector<std::string_view> GenerateRawFiltersFromPredicate(const std::string_view& input);
+    [[nodiscard]] static RawFilterData GenerateRawFilters(const PredicateDisjunction& disjunction);
+    [[nodiscard]] static std::vector<std::string_view> GenerateRawFiltersFromPredicate(const std::string_view& input);
 };
 
-inline size_t GetFlatIdx(size_t conj_idx, size_t pred_idx, size_t rf_idx) {
+[[nodiscard]] inline size_t GetFlatIdx(size_t conj_idx, size_t pred_idx, size_t rf_idx) {
     return conj_idx * kMaxPred * kMaxRfsInPred + pred_idx * kMaxRfsInPred + rf_idx;
 }
 

diff --git a/include/sparser.h b/include/sparser.h
@@ -47,11 +47,12 @@ class Sparser {
 
     void Run(const std::string& input_path, const JsonQuery& json_query);
 
-    EstimationResult Calibrate(const std::vector<std::string_view>& input, const JsonQuery& json_query,
-                               const RawFilterData& rf_data);
-    SparserSearchStats SearchCascade(const std::vector<std::string_view>& input, const JsonQuery& json_query,
-                                     const RawFilterData& rf_data, const std::shared_ptr<Node>);
-    NaiveSearchStats SearchNaive(const std::vector<std::string_view>& input, const JsonQuery& json_query);
+    [[nodiscard]] EstimationResult Calibrate(const std::vector<std::string_view>& input, const JsonQuery& json_query,
+                                             const RawFilterData& rf_data);
+    [[nodiscard]] SparserSearchStats SearchCascade(const std::vector<std::string_view>& input,
+                                                   const JsonQuery& json_query, const RawFilterData& rf_data,
+                                                   const std::shared_ptr<Node>);
+    [[nodiscard]] NaiveSearchStats SearchNaive(const std::vector<std::string_view>& input, const JsonQuery& json_query);
 
    private:
     std::unique_ptr<JsonQueryDriver> json_query_driver_;

diff --git a/src/sparser/sparser.cpp b/src/sparser/sparser.cpp
@@ -61,7 +61,8 @@ EstimationResult Sparser::Calibrate(const std::vector<std::string_view>& input,
         }
 
         auto json_query_start = rdtsc();
-        json_query_driver_->RunQuery(input[i], json_query);
+        auto query_result = json_query_driver_->RunQuery(input[i], json_query);
+        (void)query_result;  // explicitly ignore the result
         total_parser_time += (rdtsc() - json_query_start);
     }