Clang-tidy and include fix on libime/core

Author: wengxt

src/libime/core/CMakeLists.txt

@@ -50,6 +50,7 @@ set(LIBIME_HDRS
 
 set(LIBIME_SRCS
     datrie.cpp
+    dictionary.cpp
     decoder.cpp
     languagemodel.cpp
     inputbuffer.cpp

src/libime/core/datrie.cpp

@@ -20,14 +20,17 @@
 #include <cmath>
 #include <cstdint>
 #include <cstring>
+#include <fcitx-utils/macros.h>
 #include <fstream>
 #include <ios>
 #include <istream>
 #include <limits>
+#include <memory>
 #include <ostream>
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <sys/types.h>
 #include <tuple>
 #include <vector>
 

src/libime/core/datrie.h

@@ -12,11 +12,16 @@
 
 #include "libimecore_export.h"
 
+#include <cstddef>
 #include <cstdint>
 #include <fcitx-utils/macros.h>
 #include <functional>
+#include <istream>
 #include <memory>
+#include <ostream>
+#include <string>
 #include <string_view>
+#include <tuple>
 #include <vector>
 
 namespace libime {

src/libime/core/decoder.cpp

@@ -270,7 +270,8 @@ void DecoderPrivate::backwardSearch(const SegmentGraph &graph, Lattice &l,
             std::priority_queue<std::shared_ptr<NBestNode>,
                                 std::vector<std::shared_ptr<NBestNode>>,
                                 NBestNodeLess<std::shared_ptr<NBestNode>>>;
-        PriorityQueueType q, result;
+        PriorityQueueType q;
+        PriorityQueueType result;
 
         auto *eos = &lattice[nullptr][0];
         auto newNBestNode = [](const LatticeNode *node) {

src/libime/core/decoder.h

@@ -7,11 +7,16 @@
 #define _FCITX_LIBIME_CORE_DECODER_H_
 
 #include "libimecore_export.h"
+#include <cstddef>
 #include <fcitx-utils/macros.h>
 #include <libime/core/dictionary.h>
+#include <libime/core/languagemodel.h>
 #include <libime/core/lattice.h>
 #include <libime/core/segmentgraph.h>
+#include <limits>
 #include <memory>
+#include <string_view>
+#include <utility>
 
 namespace libime {
 
@@ -55,8 +60,8 @@ class LIBIMECORE_EXPORT Decoder {
         const State &state, float cost, std::unique_ptr<LatticeNodeData> data,
         bool onlyPath) const;
 
-    virtual bool needSort(const SegmentGraph &,
-                          const SegmentGraphNode *) const {
+    virtual bool needSort(const SegmentGraph & /*graph*/,
+                          const SegmentGraphNode * /*node*/) const {
         return true;
     }
 

src/libime/core/dictionary.cpp

@@ -5,3 +5,12 @@
  */
 
 #include "dictionary.h"
+#include "segmentgraph.h"
+#include <unordered_set>
+
+void libime::Dictionary::matchPrefix(
+    const SegmentGraph &graph, const GraphMatchCallback &callback,
+    const std::unordered_set<const SegmentGraphNode *> &ignore,
+    void *helper) const {
+    matchPrefixImpl(graph, callback, ignore, helper);
+}

src/libime/core/dictionary.h

@@ -10,25 +10,24 @@
 #include <functional>
 #include <libime/core/lattice.h>
 #include <libime/core/segmentgraph.h>
-#include <string_view>
+#include <memory>
+#include <unordered_set>
 
 namespace libime {
 
 class WordNode;
 
 // The callback accepts the passed path that matches the word.
-typedef std::function<void(const SegmentGraphPath &, WordNode &, float,
-                           std::unique_ptr<LatticeNodeData>)>
-    GraphMatchCallback;
+using GraphMatchCallback =
+    std::function<void(const SegmentGraphPath &, WordNode &, float,
+                       std::unique_ptr<LatticeNodeData>)>;
 
 class LIBIMECORE_EXPORT Dictionary {
 public:
     void
     matchPrefix(const SegmentGraph &graph, const GraphMatchCallback &callback,
                 const std::unordered_set<const SegmentGraphNode *> &ignore = {},
-                void *helper = nullptr) const {
-        matchPrefixImpl(graph, callback, ignore, helper);
-    }
+                void *helper = nullptr) const;
 
 protected:
     virtual void

src/libime/core/historybigram.cpp

@@ -6,19 +6,36 @@
 #include "historybigram.h"
 #include "constants.h"
 #include "datrie.h"
+#include "lattice.h"
 #include "utils.h"
 #include "zstdfilter.h"
+#include <algorithm>
+#include <array>
 #include <boost/algorithm/cxx11/all_of.hpp>
 #include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/adaptor/transformed.hpp>
 #include <boost/range/algorithm.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+#include <cassert>
 #include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <fcitx-utils/macros.h>
 #include <fcitx-utils/stringutils.h>
+#include <functional>
+#include <istream>
 #include <iterator>
+#include <list>
+#include <memory>
 #include <ostream>
 #include <stdexcept>
 #include <string>
+#include <string_view>
+#include <unordered_set>
+#include <utility>
+#include <vector>
 
 namespace libime {
 
@@ -53,7 +70,7 @@ struct WeightedTrie {
 
     void decFreq(std::string_view s, int32_t delta) {
         auto v = trie_.exactMatchSearch(s.data(), s.size());
-        if (trie_.isNoValue(v)) {
+        if (TrieType::isNoValue(v)) {
             return;
         }
         if (v <= delta) {
@@ -68,7 +85,7 @@ struct WeightedTrie {
 
     void eraseByKey(std::string_view s) {
         auto v = trie_.exactMatchSearch(s.data(), s.size());
-        if (trie_.isNoValue(v)) {
+        if (TrieType::isNoValue(v)) {
             return;
         }
         trie_.erase(s);
@@ -121,10 +138,7 @@ struct WeightedTrie {
                           }
                           words.emplace(std::move(buf));
 
-                          if (maxSize > 0 && words.size() >= maxSize) {
-                              return false;
-                          }
-                          return true;
+                          return maxSize <= 0 || words.size() < maxSize;
                       });
     }
 
@@ -168,8 +182,9 @@ class HistoryBigramPool {
         std::vector<std::string> lines;
         while (std::getline(in, buf)) {
             lines.emplace_back(buf);
-            if (lines.size() >= maxSize_)
+            if (lines.size() >= maxSize_) {
                 break;
+            }
         }
         for (auto &line : lines | boost::adaptors::reversed) {
             std::vector<std::string> sentence =
@@ -348,8 +363,6 @@ class HistoryBigramPool {
 // And then we define alpha as p = 1 / (1 + alpha).
 class HistoryBigramPrivate {
 public:
-    HistoryBigramPrivate() {}
-
     void populateSentence(std::list<std::vector<std::string>> popedSentence) {
         for (size_t i = 1; !popedSentence.empty() && i < pools_.size(); i++) {
             std::list<std::vector<std::string>> nextSentences;
@@ -405,7 +418,7 @@ HistoryBigram::HistoryBigram()
     d->poolWeight_.reserve(poolSize.size());
     for (auto size : poolSize) {
         d->pools_.emplace_back(size);
-        float portion = 1.0f;
+        float portion = 1.0F;
         if (d->pools_.size() != poolSize.size()) {
             portion *= 1 - p;
         }
@@ -472,11 +485,11 @@ float HistoryBigram::score(std::string_view prev, std::string_view cur) const {
     auto bf = d->bigramFreq(prev, cur);
     auto uf1 = d->unigramFreq(cur);
 
-    float bigramWeight = d->useOnlyUnigram_ ? 0.0f : 0.8f;
+    float bigramWeight = d->useOnlyUnigram_ ? 0.0F : 0.8F;
     // add 0.5 to avoid div 0
-    float pr = 0.0f;
+    float pr = 0.0F;
     pr += bigramWeight * float(bf) / float(uf0 + d->poolWeight_[0] / 2);
-    pr += (1.0f - bigramWeight) * float(uf1) /
+    pr += (1.0F - bigramWeight) * float(uf1) /
           float(d->unigramSize() + d->poolWeight_[0] / 2);
 
     if (pr >= 1.0) {

src/libime/core/historybigram.h

@@ -7,11 +7,15 @@
 #define _FCITX_LIBIME_CORE_HISTORYBIGRAM_H_
 
 #include "libimecore_export.h"
+#include <cstddef>
 #include <fcitx-utils/macros.h>
+#include <istream>
 #include <libime/core/lattice.h>
 #include <memory>
+#include <ostream>
 #include <string>
 #include <string_view>
+#include <unordered_set>
 #include <vector>
 
 namespace libime {

src/libime/core/inputbuffer.cpp

@@ -4,13 +4,11 @@
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 #include "inputbuffer.h"
+#include <cstddef>
 #include <fcitx-utils/utf8.h>
+#include <string_view>
 
 namespace libime {
 
-std::string_view InputBuffer::at(size_t i) const {
-    size_t start, end;
-    std::tie(start, end) = rangeAt(i);
-    return std::string_view(userInput()).substr(start, end - start);
-}
+std::string_view InputBuffer::at(size_t i) const { return viewAt(i); }
 } // namespace libime