add cpp linter (clang-tidy) workflow

.github/workflows/clang-tidy-post.yml

@@ -19,3 +19,4 @@ jobs:
           lgtm_comment_body: ''
           annotations: false
           max_comments: 10
+          num_comments_as_exitcode: false

.github/workflows/clang-tidy-review.yml

@@ -0,0 +1,28 @@
+name: clang-tidy-review
+
+# You can be more specific, but it currently only works on pull requests
+on:
+  pull_request:
+    paths: ['**.cpp', '**.h', '**.hpp', '**CMakeLists.txt', '**.cmake', '.github/workflows/clang*.yml']
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v5
+
+    - uses: ZedThree/[email protected]
+      id: review
+      with:
+        split_workflow: true
+        build_dir: build
+        apt_packages: "libsnappy-dev, libzzip-dev, zlib1g-dev, libboost-all-dev, libzstd-dev"
+        clang_tidy_checks: ''
+        cmake_command: "cmake -Bbuild -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ."
+
+    - uses: ZedThree/clang-tidy-review/[email protected]
+
+    # If there are any comments, fail the check
+    - if: steps.review.outputs.total_comments > 0
+      run: exit 1

keyvi/include/keyvi/dictionary/fsa/automata.h

@@ -406,17 +406,11 @@ class Automata final {
     return value_store_reader_->GetMsgPackedValueAsString(state_value, compression_algorithm);
   }
 
-  std::string GetStatistics() const {
-    return dictionary_properties_->GetStatistics();
-  }
+  [[nodiscard]] std::string GetStatistics() const { return dictionary_properties_->GetStatistics(); }
 
-  const std::string& GetManifest() const {
-    return dictionary_properties_->GetManifest();
-  }
+  [[nodiscard]] const std::string& GetManifest() const { return dictionary_properties_->GetManifest(); }
 
-  const uint64_t GetVersion() const {
-    return dictionary_properties_->GetVersion();
-  }
+  [[nodiscard]] const uint64_t GetVersion() const { return dictionary_properties_->GetVersion(); }
 
  private:
   dictionary_properties_t dictionary_properties_;
@@ -478,9 +472,7 @@ class Automata final {
 
   friend class keyvi::dictionary::SecondaryKeyDictionary;
 
-  const dictionary_properties_t& GetDictionaryProperties() const {
-    return dictionary_properties_;
-  }
+  [[nodiscard]] const dictionary_properties_t& GetDictionaryProperties() const { return dictionary_properties_; }
 };
 
 // shared pointer

keyvi/include/keyvi/dictionary/fsa/comparable_state_traverser.h

@@ -31,6 +31,7 @@
 #include <vector>
 
 #include "keyvi/dictionary/fsa/automata.h"
+#include "keyvi/dictionary/fsa/traversal/traversal_base.h"
 #include "keyvi/dictionary/fsa/traverser_types.h"
 
 // #define ENABLE_TRACING
@@ -65,7 +66,7 @@ class ComparableStateTraverser final {
   using label_t = typename innerTraverserType::label_t;
   using transition_t = typename innerTraverserType::transition_t;
 
-  explicit ComparableStateTraverser(const innerTraverserType &&traverser, const bool advance = true,
+  explicit ComparableStateTraverser(const innerTraverserType&& traverser, const bool advance = true,
                                     const size_t order = 0)
       : state_traverser_(std::move(traverser)), order_(order) {
     if (advance) {
@@ -85,7 +86,7 @@ class ComparableStateTraverser final {
       : ComparableStateTraverser(f, f->GetStartState(), advance, order) {}
 
   explicit ComparableStateTraverser(const automata_t f, const uint64_t start_state,
-                                    traversal::TraversalPayload<transition_t> &&payload, const bool advance = true,
+                                    traversal::TraversalPayload<transition_t>&& payload, const bool advance = true,
                                     const size_t order = 0)
       : state_traverser_(f, start_state, std::move(payload), false), order_(order) {
     if (advance) {
@@ -94,13 +95,13 @@ class ComparableStateTraverser final {
   }
 
   ComparableStateTraverser() = delete;
-  ComparableStateTraverser &operator=(ComparableStateTraverser const &) = delete;
-  ComparableStateTraverser(const ComparableStateTraverser &that) = delete;
+  ComparableStateTraverser& operator=(ComparableStateTraverser const&) = delete;
+  ComparableStateTraverser(const ComparableStateTraverser& that) = delete;
 
   /**
    * Comparison of the state traverser for the purpose of ordering them
    */
-  bool operator<(const ComparableStateTraverser &rhs) const {
+  bool operator<(const ComparableStateTraverser& rhs) const {
     int compare = std::memcmp(label_stack_.data(), rhs.label_stack_.data(),
                               std::min(label_stack_.size(), rhs.label_stack_.size()) * sizeof(label_t));
     if (compare != 0) {
@@ -114,24 +115,24 @@ class ComparableStateTraverser final {
     return order_ > rhs.order_;
   }
 
-  bool operator>(const ComparableStateTraverser &rhs) const { return rhs.operator<(*this); }
+  bool operator>(const ComparableStateTraverser& rhs) const { return rhs.operator<(*this); }
 
-  bool operator<=(const ComparableStateTraverser &rhs) const { return !operator>(rhs); }
+  bool operator<=(const ComparableStateTraverser& rhs) const { return !operator>(rhs); }
 
-  bool operator>=(const ComparableStateTraverser &rhs) const { return !operator<(rhs); }
+  bool operator>=(const ComparableStateTraverser& rhs) const { return !operator<(rhs); }
 
   /**
    * Compare traverser with another one, _ignoring_ the order value
    */
-  bool operator==(const ComparableStateTraverser &rhs) const {
+  bool operator==(const ComparableStateTraverser& rhs) const {
     if (label_stack_.size() != rhs.label_stack_.size()) {
       return false;
     }
 
     return std::memcmp(label_stack_.data(), rhs.label_stack_.data(), label_stack_.size() * sizeof(label_t)) == 0;
   }
 
-  bool operator!=(const ComparableStateTraverser &rhs) const { return !operator==(rhs); }
+  bool operator!=(const ComparableStateTraverser& rhs) const { return !operator==(rhs); }
 
   operator bool() const { return state_traverser_; }
 
@@ -162,7 +163,7 @@ class ComparableStateTraverser final {
 
   label_t GetStateLabel() const { return state_traverser_.GetStateLabel(); }
 
-  const std::vector<label_t> &GetStateLabels() const { return label_stack_; }
+  [[nodiscard]] const std::vector<label_t>& GetStateLabels() const { return label_stack_; }
 
   size_t GetOrder() const { return order_; }
 
@@ -186,22 +187,22 @@ class ComparableStateTraverser final {
   template <class nearInnerTraverserType>
   friend class matching::NearMatching;
 
-  traversal::TraversalState<transition_t> &GetStates() { return state_traverser_.GetStates(); }
+  traversal::TraversalState<transition_t>& GetStates() { return state_traverser_.GetStates(); }
 
-  traversal::TraversalPayload<transition_t> &GetTraversalPayload() { return state_traverser_.GetTraversalPayload(); }
+  traversal::TraversalPayload<transition_t>& GetTraversalPayload() { return state_traverser_.GetTraversalPayload(); }
 
-  const traversal::TraversalPayload<transition_t> &GetTraversalPayload() const {
+  [[nodiscard]] const traversal::TraversalPayload<transition_t>& GetTraversalPayload() const {
     return state_traverser_.GetTraversalPayload();
   }
 };
 
-inline bool CompareWeights(const traversal::TraversalState<traversal::WeightedTransition> &i,
-                           const traversal::TraversalState<traversal::WeightedTransition> &j) {
+inline bool CompareWeights(const traversal::TraversalState<traversal::WeightedTransition>& i,
+                           const traversal::TraversalState<traversal::WeightedTransition>& j) {
   return i.GetNextInnerWeight() == j.GetNextInnerWeight();
 }
 
 template <>
-inline bool ComparableStateTraverser<WeightedStateTraverser>::operator<(const ComparableStateTraverser &rhs) const {
+inline bool ComparableStateTraverser<WeightedStateTraverser>::operator<(const ComparableStateTraverser& rhs) const {
   TRACE("operator< (weighted state specialization)");
 
   TRACE("depth %ld %ld", state_traverser_.GetDepth(), rhs.state_traverser_.GetDepth());
@@ -231,7 +232,7 @@ inline bool ComparableStateTraverser<WeightedStateTraverser>::operator<(const Co
 }
 
 template <>
-inline bool ComparableStateTraverser<NearStateTraverser>::operator==(const ComparableStateTraverser &rhs) const {
+inline bool ComparableStateTraverser<NearStateTraverser>::operator==(const ComparableStateTraverser& rhs) const {
   if (label_stack_.size() != rhs.label_stack_.size()) {
     return false;
   }
@@ -244,7 +245,7 @@ inline bool ComparableStateTraverser<NearStateTraverser>::operator==(const Compa
 }
 
 template <>
-inline bool ComparableStateTraverser<NearStateTraverser>::operator<(const ComparableStateTraverser &rhs) const {
+inline bool ComparableStateTraverser<NearStateTraverser>::operator<(const ComparableStateTraverser& rhs) const {
   TRACE("operator< (near state specialization)");
 
   if (GetTraversalPayload().exact != rhs.GetTraversalPayload().exact) {

keyvi/include/keyvi/dictionary/fsa/internal/lru_generation_cache.h

@@ -66,21 +66,21 @@ class LeastRecentlyUsedGenerationsCache final {
 
   ~LeastRecentlyUsedGenerationsCache() {
     delete current_generation_;
-    for (MinimizationHash<EntryT> *generation : generations_) {
+    for (MinimizationHash<EntryT>* generation : generations_) {
       delete generation;
     }
   }
 
   LeastRecentlyUsedGenerationsCache() = delete;
-  LeastRecentlyUsedGenerationsCache &operator=(LeastRecentlyUsedGenerationsCache const &) = delete;
-  LeastRecentlyUsedGenerationsCache(const LeastRecentlyUsedGenerationsCache &that) = delete;
+  LeastRecentlyUsedGenerationsCache& operator=(LeastRecentlyUsedGenerationsCache const&) = delete;
+  LeastRecentlyUsedGenerationsCache(const LeastRecentlyUsedGenerationsCache& that) = delete;
 
   /** Add this object.
    * @param key The key to add
    */
   void Add(EntryT key) {
     if (current_generation_->Size() >= size_per_generation_) {
-      MinimizationHash<EntryT> *newGeneration = nullptr;
+      MinimizationHash<EntryT>* newGeneration = nullptr;
       if (generations_.size() + 1 == max_number_of_generations_) {
         // remove(free) the first generation
         newGeneration = generations_[0];
@@ -101,7 +101,7 @@ class LeastRecentlyUsedGenerationsCache final {
   }
 
   template <typename EqualityType>
-  const EntryT Get(EqualityType &key) {  // NOLINT
+  const EntryT Get(EqualityType& key) {  // NOLINT
     EntryT state = current_generation_->Get(key);
 
     if (!state.IsEmpty()) {
@@ -126,7 +126,7 @@ class LeastRecentlyUsedGenerationsCache final {
    */
   void Clear() {
     current_generation_->Clear();
-    for (MinimizationHash<EntryT> *generation : generations_) {
+    for (MinimizationHash<EntryT>* generation : generations_) {
       delete generation;
     }
     generations_.clear();
@@ -148,8 +148,8 @@ class LeastRecentlyUsedGenerationsCache final {
  private:
   size_t size_per_generation_;
   size_t max_number_of_generations_;
-  MinimizationHash<EntryT> *current_generation_;
-  std::vector<MinimizationHash<EntryT> *> generations_;
+  MinimizationHash<EntryT>* current_generation_;
+  std::vector<MinimizationHash<EntryT>*> generations_;
 };
 
 } /* namespace internal */

keyvi/include/keyvi/dictionary/fsa/internal/minimization_hash.h

@@ -180,7 +180,7 @@ class MinimizationHash final {
    * @return the equal state or an empty value
    */
   template <typename EqualityType>
-  inline const T Get(EqualityType &key) const {  // NOLINT
+  inline const T Get(EqualityType& key) const {  // NOLINT
     size_t hash = key.GetHashcode() & 0x7fffffff;
     size_t bucket = hash % hash_size_;
 
@@ -209,7 +209,7 @@ class MinimizationHash final {
    * @return the equal state or an empty value
    */
   template <typename EqualityType>
-  inline const T GetAndMove(EqualityType &key, MinimizationHash<T> *other) {  // NOLINT
+  inline const T GetAndMove(EqualityType& key, MinimizationHash<T>* other) {  // NOLINT
     size_t hash = key.GetHashcode() & 0x7fffffff;
     size_t bucket = hash % hash_size_;
     T entry = entries_[bucket];
@@ -325,10 +325,10 @@ class MinimizationHash final {
   size_t rehash_limit_ = 0;
 
   /// the actual data storage
-  T *entries_ = 0;
+  T* entries_ = 0;
 
   /// overflow data storage for colliding entries
-  T *overflow_entries_ = 0;
+  T* overflow_entries_ = 0;
 
   /// number of items in the data
   size_t count_ = 0;
@@ -399,10 +399,10 @@ class MinimizationHash final {
     hash_size_ = hash_size_step_table_[hash_size_step_];
     rehash_limit_ = static_cast<int>(hash_size_ * load_factor_);
 
-    T *old_entries = entries_;
+    T* old_entries = entries_;
     entries_ = new T[hash_size_];
 
-    T *old_overflow_entries = overflow_entries_;
+    T* old_overflow_entries = overflow_entries_;
     overflow_entries_size_ = std::min(hash_size_ >> 2, max_cookie_size_);
     overflow_entries_ = new T[overflow_entries_size_];
 

keyvi/include/keyvi/dictionary/fsa/internal/sparse_array_persistence.h

@@ -200,9 +200,7 @@ class SparseArrayPersistence final {
     TRACE("Wrote Transitions, stream at %d", stream.tellp());
   }
 
-  size_t GetChunkSizeExternalTransitions() const {
-    return transitions_extern_->GetChunkSize();
-  }
+  size_t GetChunkSizeExternalTransitions() const { return transitions_extern_->GetChunkSize(); }
 
   uint32_t GetVersion() const;
 

keyvi/include/keyvi/dictionary/fsa/state_traverser.h

@@ -55,7 +55,7 @@ class StateTraverser final {
     this->operator++(0);
   }
 
-  StateTraverser(automata_t f, const uint64_t start_state, traversal::TraversalPayload<TransitionT> &&payload,
+  StateTraverser(automata_t f, const uint64_t start_state, traversal::TraversalPayload<TransitionT>&& payload,
                  const bool advance = true)
       : fsa_(f), current_weight_(0), current_label_(0), stack_(std::move(payload)) {
     current_state_ = start_state;
@@ -81,10 +81,10 @@ class StateTraverser final {
   }
 
   StateTraverser() = delete;
-  StateTraverser &operator=(StateTraverser const &) = delete;
-  StateTraverser(const StateTraverser &that) = delete;
+  StateTraverser& operator=(StateTraverser const&) = delete;
+  StateTraverser(const StateTraverser& that) = delete;
 
-  StateTraverser(StateTraverser &&other)
+  StateTraverser(StateTraverser&& other)
       : fsa_(other.fsa_),
         current_state_(other.current_state_),
         current_weight_(other.current_weight_),
@@ -182,13 +182,13 @@ class StateTraverser final {
 
   template <class innerTraverserType>
   friend class ComparableStateTraverser;
-  const traversal::TraversalStack<TransitionT> &GetStack() const { return stack_; }
+  const traversal::TraversalStack<TransitionT>& GetStack() const { return stack_; }
 
-  traversal::TraversalState<transition_t> &GetStates() { return stack_.GetStates(); }
+  traversal::TraversalState<transition_t>& GetStates() { return stack_.GetStates(); }
 
-  traversal::TraversalPayload<TransitionT> &GetTraversalPayload() { return stack_.traversal_stack_payload; }
+  traversal::TraversalPayload<TransitionT>& GetTraversalPayload() { return stack_.traversal_stack_payload; }
 
-  const traversal::TraversalPayload<TransitionT> &GetTraversalPayload() const { return stack_.traversal_stack_payload; }
+  const traversal::TraversalPayload<TransitionT>& GetTraversalPayload() const { return stack_.traversal_stack_payload; }
 };
 
 /**