Apply clang-tidy to headers

Author: jkurdek

.clang-tidy

@@ -19,8 +19,8 @@ HeaderFilterRegex: ''
 FormatStyle:     none
 CheckOptions:
   - key: readability-identifier-length.IgnoredVariableNames
-    value: 'x|y|z'
+    value: 'x|y|z|rf'
   - key: readability-identifier-length.IgnoredParameterNames
-    value: 'x|y|z'
+    value: 'x|y|z|rf'
   - key: bugprone-easily-swappable-parameters.MinimumLength
-    value: '3'
+    value: '4'

include/cascade_builder.h

@@ -1,24 +1,30 @@
 #ifndef CASCADE_BUILDER_H_
 #define CASCADE_BUILDER_H_
 
+#include <array>
 #include <bitset>
+#include <utility>
+#include <vector>
+#include <memory>
+#include <cstddef>
 
+#include "config.h"
 #include "json_facade.h"
 #include "node.h"
 #include "raw_filter.h"
 
 class CascadeBuilder {
    public:
-    CascadeBuilder(const PredicateDisjunction& disjunction, const RawFilterData& raw_filter_data)
-        : disjunction_(disjunction), rf_data_(raw_filter_data) {}
+    CascadeBuilder(PredicateDisjunction  disjunction, const RawFilterData& raw_filter_data)
+        : disjunction_(std::move(disjunction)), rf_data_(raw_filter_data) {}
 
     [[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);
     std::shared_ptr<Node> parse_node = std::make_shared<Node>(0, 0, 0, nullptr, nullptr, NodeType::PARSE);
-    const PredicateDisjunction& disjunction_;
-    const RawFilterData& rf_data_;
+    PredicateDisjunction disjunction_;
+    RawFilterData rf_data_;
     std::bitset<kMaxConj> used_conjunctions_;
     std::array<std::array<std::bitset<kMaxRfsInPred>, kMaxPred>, kMaxConj> used_rfs_;
 

include/cascade_evaluator.h

@@ -9,8 +9,8 @@
 #include "node.h"
 
 struct EstimationResult {
-    double average_parse_time;
-    double average_rf_time;
+    double average_parse_time{};
+    double average_rf_time{};
     std::array<std::bitset<kSampleSize>, kTotalMaxRfs> bitsets;
 };
 
@@ -21,7 +21,7 @@ class CascadeEvaluator {
     [[nodiscard]] double EvaluateCascade(const std::shared_ptr<Node>& cascade);
 
    private:
-    const EstimationResult& estimation_result_;
+    EstimationResult estimation_result_;
 
     [[nodiscard]] double EvaluateSubtreeCost(const std::shared_ptr<Node>& subtree,
                                              const std::bitset<kSampleSize>& active_mask);

include/common.h

@@ -7,9 +7,12 @@ using bench_timer_t = std::chrono::time_point<std::chrono::steady_clock>;
 
 [[nodiscard]] inline bench_timer_t benchmark_start() { return std::chrono::steady_clock::now(); }
 
+constexpr double MICROSECONDS_IN_SECOND = 1'000'000.0;
+
 [[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;
+    return static_cast<double>(std::chrono::duration_cast<std::chrono::microseconds>(end - start).count()) /
+           MICROSECONDS_IN_SECOND;
 }
 
 #endif  // COMMON_H_

include/input_reader.h

@@ -2,6 +2,7 @@
 #define INPUT_READER_H_
 
 #include <string>
+#include <string_view>
 #include <vector>
 
 class InputReader {

include/json_facade.h

@@ -2,8 +2,10 @@
 #define JSON_FACADE_H_
 
 #include <memory>
+#include <ostream>
 #include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 struct Predicate {
@@ -24,28 +26,33 @@ class JsonQuery {
     PredicateDisjunction disjunction_;
 
    public:
-    explicit JsonQuery(const PredicateDisjunction& disjunction) : disjunction_(disjunction) {}
+    explicit JsonQuery(PredicateDisjunction disjunction) : disjunction_(std::move(disjunction)) {}
 
-    [[nodiscard]] const inline PredicateDisjunction& GetDisjunction() const { return disjunction_; }
+    [[nodiscard]] const PredicateDisjunction& GetDisjunction() const { return disjunction_; }
     [[nodiscard]] std::string ToString() const;
 
-    friend std::ostream& operator<<(std::ostream& os, const JsonQuery& query);
+    friend std::ostream& operator<<(std::ostream& outStream, const JsonQuery& query);
 };
 
 class JsonFacade {
    public:
+    JsonFacade() = default;
+    JsonFacade(const JsonFacade&) = delete;
+    JsonFacade& operator=(const JsonFacade&) = delete;
+    JsonFacade(JsonFacade&&) = delete;
+    JsonFacade& operator=(JsonFacade&&) = delete;
     virtual ~JsonFacade() = default;
     [[nodiscard]] virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) = 0;
 };
 
 class RapidJsonFacade : public JsonFacade {
    public:
-    [[nodiscard]] virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) override;
+    [[nodiscard]] bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) override;
 };
 
 class SimdJsonFacade : public JsonFacade {
    public:
-    [[nodiscard]] virtual bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) override;
+    [[nodiscard]] bool EvaluateQuery(std::string_view jsonStr, const JsonQuery& query) override;
 };
 
 class JsonQueryDriver {

include/node.h

@@ -4,9 +4,11 @@
 #include <cstdint>
 #include <iostream>
 #include <memory>
+#include <string>
+#include <utility>
 
 #include "raw_filter.h"
-enum class NodeType { INTER, FAIL, PARSE };
+enum class NodeType : std::uint8_t { INTER, FAIL, PARSE };
 
 struct Node {
     uint32_t conjunction_idx;
@@ -21,12 +23,12 @@ struct Node {
         : conjunction_idx(conj_idx),
           predicate_idx(pred_idx),
           raw_filter_idx(rf_idx),
-          left(left_subtree),
-          right(right_subtree),
+          left(std::move(left_subtree)),
+          right(std::move(right_subtree)),
           type(node_type) {}
 };
 
 void PrettyPrint(const std::shared_ptr<Node>& node, const RawFilterData& rf_data, const std::string& prefix = "",
-                 bool isLeft = true, std::ostream& os = std::cout);
+                 bool isLeft = true, std::ostream& outStream = std::cout);
 
 #endif  // NODE_H_

include/raw_filter.h

@@ -2,7 +2,9 @@
 #define RAW_FILTER_H_
 
 #include <array>
+#include <cstddef>
 #include <string_view>
+#include <vector>
 
 #include "config.h"
 #include "json_facade.h"
@@ -21,7 +23,7 @@ class RawFilterQueryGenerator {
 };
 
 [[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;
+    return (conj_idx * kMaxPred * kMaxRfsInPred) + (pred_idx * kMaxRfsInPred) + rf_idx;
 }
 
 #endif  // RAW_FILTER_H_

include/sparser.h

@@ -3,7 +3,9 @@
 
 #include <cstddef>
 #include <memory>
+#include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 #include "cascade_evaluator.h"

src/main.cpp

@@ -1,5 +1,9 @@
+#include <exception>
+#include <iostream>
 #include <memory>
 #include <span>
+#include <string>
+#include <utility>
 
 #include "json_facade.h"
 #include "sparser.h"
@@ -15,10 +19,10 @@ int main(int argc, char* argv[]) {
 
         const std::string filename = args[1];
 
-        Predicate pred1{.key = "text", .value = "Lord of the Rings"};
+        const Predicate pred1{.key = "text", .value = "Lord of the Rings"};
 
-        PredicateConjunction conj1{{pred1}};
-        PredicateDisjunction disj{{conj1}};
+        const PredicateConjunction conj1{{pred1}};
+        const PredicateDisjunction disj{{conj1}};
 
         auto facade = std::make_unique<RapidJsonFacade>();
         auto json_query_driver = std::make_unique<JsonQueryDriver>(std::move(facade));