feat: make bucket-finder default

QVectorSearch/mainwindow.cpp

@@ -28,12 +28,12 @@ MainWindow::MainWindow(QWidget *parent)
 MainWindow::~MainWindow() { delete ui; }
 
 void MainWindow::setupAlgorithmSelector() {
+  search_algorithms_.appendRow(new QStandardItem("Bucket search"));
   search_algorithms_.appendRow(new QStandardItem("Linear search"));
   search_algorithms_.appendRow(new QStandardItem("Sorted linear search"));
   search_algorithms_.appendRow(new QStandardItem("Parallel search"));
   search_algorithms_.appendRow(new QStandardItem("Tree search"));
   search_algorithms_.appendRow(new QStandardItem("Grouped search"));
-  search_algorithms_.appendRow(new QStandardItem("Bucket search"));
 }
 
 void MainWindow::setupWordListSourceSelector() {
@@ -89,8 +89,8 @@ void MainWindow::search(const QString &search_term) {
   timer.stop();
 
   std::stringstream status_message;
-  status_message << "search took " << timer << ", found "
+  status_message << "search took " << timer << ", found " << results.size()
-                 << std::distance(results.begin(), results.end()) << " results";
+                 << " result(s) in " << word_list_.size() << " words.";
   ui->mainStatusBar->showMessage(QString::fromStdString(status_message.str()));
 
   showResults(results);
@@ -102,28 +102,27 @@ void MainWindow::createSelectedFinder() {
   switch (selectedFinder) {
   case 0:
   default:
-    finder_ = std::make_unique<LinearFinder>(word_list_);
+    finder_ = std::make_unique<BucketFinder>(word_list_);
     break;
   case 1:
-    finder_ = std::make_unique<SortedLinearFinder>(word_list_);
+    finder_ = std::make_unique<LinearFinder>(word_list_);
     break;
   case 2:
-    finder_ = std::make_unique<ParallelFinder>(word_list_);
+    finder_ = std::make_unique<SortedLinearFinder>(word_list_);
     break;
   case 3:
-    finder_ = std::make_unique<TreeFinder>(word_list_);
+    finder_ = std::make_unique<ParallelFinder>(word_list_);
     break;
   case 4:
-    finder_ = std::make_unique<GroupedFinder>(word_list_);
+    finder_ = std::make_unique<TreeFinder>(word_list_);
     break;
   case 5:
-    finder_ = std::make_unique<BucketFinder>(word_list_);
+    finder_ = std::make_unique<GroupedFinder>(word_list_);
     break;
   }
 }
 
-void MainWindow::showResults(
+void MainWindow::showResults(const WordRefList &results) {
-    const std::forward_list<const std::string *> &results) {
   QStringList ui_results;
   for (auto word : results) {
     ui_results.append(QString::fromStdString(*word));
@@ -160,3 +159,9 @@ void MainWindow::on_wordListSizeSelector_valueChanged(int) {
   search(ui->searchInput->displayText());
   QGuiApplication::restoreOverrideCursor();
 }
+
+void MainWindow::on_searchInput_returnPressed() {
+  QGuiApplication::setOverrideCursor(Qt::WaitCursor);
+  search(ui->searchInput->displayText());
+  QGuiApplication::restoreOverrideCursor();
+}

QVectorSearch/mainwindow.h

@@ -36,13 +36,14 @@ private:
   void loadWordList(std::filesystem::path path);
   void search(const QString &search_term);
   void createSelectedFinder();
-  void showResults(const std::forward_list<const std::string *> &results);
+  void showResults(const WordRefList &results);
 
 private slots:
   void on_searchInput_textChanged(const QString &search_term);
   void on_searchAlgorithmSelector_currentIndexChanged(int);
   void on_wordListSourceSelector_currentIndexChanged(int);
   void on_wordListSizeSelector_valueChanged(int);
+  void on_searchInput_returnPressed();
 
 private:
   Ui::MainWindow *ui;

lib_vector_search/CMakeLists.txt

@@ -19,6 +19,7 @@ add_library(
   include/tree_finder.h
   src/grouped_finder.cpp
   include/grouped_finder.h
+  include/finder.h
   src/bucket_finder.cpp
   include/bucket_finder.h)
 

lib_vector_search/include/bucket_finder.h

@@ -10,12 +10,9 @@ private:
   std::map<const char, WordRefList> groups_;
 
 public:
-  Bucket() = default;
-
   void insert(const WordList &word_list, size_t first_index, size_t last_index);
 
-  std::forward_list<const std::string *>
+  WordRefList find_prefix(std::string_view search_term) const;
-  find_prefix(std::string_view search_term) const;
 };
 
 class BucketFinder : public Finder {
@@ -25,6 +22,5 @@ private:
 public:
   BucketFinder(const WordList &word_list);
 
-  std::forward_list<const std::string *>
+  WordRefList find_prefix(std::string_view search_term) const override;
-  find_prefix(std::string_view search_term) const override;
 };

lib_vector_search/include/finder.h

@@ -1,12 +1,10 @@
 #pragma once
 
-#include <forward_list>
+#include "word_list.h"
-#include <string>
 
 class Finder {
 public:
   virtual ~Finder() = default;
 
-  virtual std::forward_list<const std::string *>
+  virtual WordRefList find_prefix(std::string_view search_term) const = 0;
-  find_prefix(std::string_view search_term) const = 0;
 };

lib_vector_search/include/grouped_finder.h

@@ -12,6 +12,6 @@ private:
 public:
   GroupedFinder(const WordList &word_list);
 
-  virtual std::forward_list<const std::string *>
+  virtual WordRefList
   find_prefix(std::string_view search_prefix) const override;
 };

lib_vector_search/include/linear_finder.h

@@ -10,6 +10,5 @@ private:
 public:
   LinearFinder(const WordList &word_list);
 
-  std::forward_list<const std::string *>
+  WordRefList find_prefix(std::string_view search_term) const override;
-  find_prefix(std::string_view search_term) const override;
 };

lib_vector_search/include/parallel_finder.h

@@ -10,6 +10,5 @@ private:
 public:
   ParallelFinder(const WordList &word_list);
 
-  std::forward_list<const std::string *>
+  WordRefList find_prefix(std::string_view search_prefix) const override;
-  find_prefix(std::string_view search_prefix) const override;
 };

lib_vector_search/include/sorted_linear_finder.h

@@ -10,6 +10,5 @@ private:
 public:
   SortedLinearFinder(const WordList &word_list);
 
-  std::forward_list<const std::string *>
+  WordRefList find_prefix(std::string_view search_term) const override;
-  find_prefix(std::string_view search_term) const override;
 };

lib_vector_search/include/tree_finder.h

@@ -7,14 +7,14 @@
 
 class SearchTreeNode {
 private:
-  std::forward_list<const std::string *> words_;
+  WordRefList words_;
   std::map<const char, SearchTreeNode> children_;
 
 public:
   void insert(std::string_view partial_word, const std::string *original_word);
   const SearchTreeNode *find(std::string_view search_term) const;
 
-  std::forward_list<const std::string *> words() const;
+  WordRefList words() const;
 };
 
 class SearchTree : public SearchTreeNode {
@@ -29,6 +29,5 @@ private:
 public:
   TreeFinder(const WordList &word_list);
 
-  virtual std::forward_list<const std::string *>
+  WordRefList find_prefix(std::string_view search_term) const override;
-  find_prefix(std::string_view search_term) const override;
 };

lib_vector_search/include/word_list.h

@@ -1,23 +1,26 @@
 #pragma once
 
 #include <filesystem>
-#include <forward_list>
 #include <mutex>
 #include <string>
 #include <vector>
 
+class WordRefList;
+
 class WordList : public std::vector<std::string> {
 public:
   WordList &multiply(size_t factor);
   WordList &shuffle();
 
+  static WordList oneCap();
   static WordList fourCaps();
   static WordList fromFile(const std::filesystem::path &path);
 
-  static void find_prefix_in_range(
+  static void find_prefix_in_range(const WordList &word_list,
-      const WordList &word_list, const std::string_view &search_prefix,
+                                   const std::string_view &search_prefix,
-      size_t start_index, size_t end_index,
+                                   size_t start_index, size_t end_index,
-      std::forward_list<const std::string *> &result, std::mutex &result_mutex);
+                                   WordRefList &result,
+                                   std::mutex &result_mutex);
 };
 
 class WordRefList : public std::vector<const std::string *> {
@@ -25,8 +28,9 @@ public:
   WordRefList() = default;
   WordRefList(const WordList &source);
 
-  static void find_prefix_in_range(
+  static void find_prefix_in_range(const WordRefList &word_list,
-      const WordRefList &word_list, const std::string_view &search_prefix,
+                                   const std::string_view &search_prefix,
-      size_t start_index, size_t end_index,
+                                   size_t start_index, size_t end_index,
-      std::forward_list<const std::string *> &result, std::mutex &result_mutex);
+                                   WordRefList &result,
+                                   std::mutex &result_mutex);
 };

lib_vector_search/src/bucket_finder.cpp

@@ -12,19 +12,19 @@ void Bucket::insert(const WordList &word_list, size_t first_index,
   }
 }
 
-std::forward_list<const std::string *>
+WordRefList Bucket::find_prefix(std::string_view search_term) const {
-Bucket::find_prefix(std::string_view search_term) const {
+  auto group_it = groups_.find(search_term.front());
-  const auto group = groups_.find(search_term.front());
+  if (group_it == groups_.cend()) {
-  if (group == groups_.cend()) {
     return {};
   }
 
-  std::forward_list<const std::string *> result;
+  WordRefList result;
-  for (const auto *word : group->second) {
+  for (const auto *word : group_it->second) {
     if (word->starts_with(search_term)) {
-      result.push_front(word);
+      result.push_back(word);
     }
   }
+
   return result;
 }
 
@@ -40,45 +40,45 @@ BucketFinder::BucketFinder(const WordList &word_list) {
 
   buckets_.resize(bucket_count);
 
-  std::vector<std::thread> insert_threads;
+  std::vector<std::thread> threads;
   for (auto bucket_index = 0; bucket_index < bucket_count; ++bucket_index) {
-    const size_t first_index = bucket_index * bucket_size;
-    const size_t last_index = (bucket_index == bucket_count - 1)
-                                  ? word_list_size
-                                  : (bucket_index + 1) * bucket_size;
-
     auto &bucket = buckets_[bucket_index];
 
-    insert_threads.emplace_back([&bucket, &word_list, first_index, last_index] {
+    bool is_last_bucket = bucket_index == bucket_count - 1;
+
+    const size_t first_index = bucket_index * bucket_size;
+    const size_t last_index =
+        is_last_bucket ? word_list_size : first_index + bucket_size;
+
+    threads.emplace_back([&, first_index, last_index] {
       bucket.insert(word_list, first_index, last_index);
     });
   }
 
-  for (auto &thread : insert_threads) {
+  for (auto &thread : threads) {
     thread.join();
   }
 }
 
-std::forward_list<const std::string *>
+WordRefList BucketFinder::find_prefix(std::string_view search_term) const {
-BucketFinder::find_prefix(std::string_view search_term) const {
+  WordRefList search_results;
-  std::forward_list<const std::string *> result;
+  std::mutex search_results_mutex;
-  std::mutex result_mutex;
 
-  std::vector<std::thread> search_threads;
+  std::vector<std::thread> threads;
   for (const auto &bucket : buckets_) {
-
+    threads.emplace_back([&] {
-    search_threads.emplace_back([&] {
+      auto thread_search_results = bucket.find_prefix(search_term);
-      auto thread_result = bucket.find_prefix(search_term);
+      if (!thread_search_results.empty()) {
-      if (!thread_result.empty()) {
+        std::lock_guard result_lock(search_results_mutex);
-        std::lock_guard<std::mutex> result_lock(result_mutex);
+        std::move(thread_search_results.begin(), thread_search_results.end(),
-        result.merge(thread_result);
+                  std::back_inserter(search_results));
       }
     });
   }
 
-  for (auto &thread : search_threads) {
+  for (auto &thread : threads) {
     thread.join();
   }
 
-  return result;
+  return search_results;
 };

lib_vector_search/src/grouped_finder.cpp

@@ -5,8 +5,7 @@
 #include <thread>
 #include <vector>
 
-using std::mutex, std::vector, std::thread, std::string, std::forward_list,
+using std::mutex, std::vector, std::thread, std::string, std::string_view;
-    std::string_view;
 
 GroupedFinder::GroupedFinder(const WordList &word_list) {
   for (const auto &word : word_list) {
@@ -14,8 +13,7 @@ GroupedFinder::GroupedFinder(const WordList &word_list) {
   }
 }
 
-forward_list<const string *>
+WordRefList GroupedFinder::find_prefix(string_view search_prefix) const {
-GroupedFinder::find_prefix(string_view search_prefix) const {
   const auto group = groups_.find(search_prefix.front());
   if (group == groups_.cend()) {
     return {};
@@ -27,7 +25,7 @@ GroupedFinder::find_prefix(string_view search_prefix) const {
   const auto thread_count =
       std::min<size_t>(std::thread::hardware_concurrency(), word_list_size);
 
-  forward_list<const string *> result;
+  WordRefList result;
   mutex result_mutex;
 
   vector<thread> search_threads;

lib_vector_search/src/linear_finder.cpp

@@ -1,18 +1,16 @@
 #include "linear_finder.h"
-#include <forward_list>
 #include <string_view>
 
-using std::string, std::forward_list, std::string_view;
+using std::string, std::string_view;
 
 LinearFinder::LinearFinder(const WordList &word_list) : word_list_(word_list) {}
 
-forward_list<const string *>
+WordRefList LinearFinder::find_prefix(string_view search_term) const {
-LinearFinder::find_prefix(string_view search_term) const {
+  WordRefList matching_words;
-  forward_list<const string *> matching_words;
 
   for (const auto &current_word : word_list_) {
     if (current_word.starts_with(search_term)) {
-      matching_words.push_front(&current_word);
+      matching_words.push_back(&current_word);
     }
   }
 

lib_vector_search/src/parallel_finder.cpp

@@ -3,15 +3,13 @@
 #include <mutex>
 #include <thread>
 
-using std::mutex, std::thread, std::vector, std::forward_list, std::string,
+using std::mutex, std::thread, std::vector, std::string, std::string_view;
-    std::string_view;
 
 ParallelFinder::ParallelFinder(const WordList &word_list)
     : word_list_(word_list) {}
 
-forward_list<const string *>
+WordRefList ParallelFinder::find_prefix(string_view search_prefix) const {
-ParallelFinder::find_prefix(string_view search_prefix) const {
+  WordRefList result;
-  forward_list<const string *> result;
   mutex result_mutex;
 
   const size_t word_list_size = word_list_.size();

lib_vector_search/src/sorted_linear_finder.cpp

@@ -2,7 +2,7 @@
 
 #include <algorithm>
 
-using std::forward_list, std::string, std::string_view;
+using std::string, std::string_view;
 
 SortedLinearFinder::SortedLinearFinder(const WordList &word_list)
     : word_list_(word_list) {
@@ -11,14 +11,13 @@ SortedLinearFinder::SortedLinearFinder(const WordList &word_list)
       [](const string *left, const string *right) { return *left < *right; });
 }
 
-forward_list<const string *>
+WordRefList SortedLinearFinder::find_prefix(string_view search_term) const {
-SortedLinearFinder::find_prefix(string_view search_term) const {
+  WordRefList matching_words;
-  forward_list<const string *> matching_words;
 
   bool in_range = false;
   for (const auto *word : word_list_) {
     if (word->starts_with(search_term)) {
-      matching_words.push_front(word);
+      matching_words.push_back(word);
       in_range = true;
     } else if (in_range) {
       break;

lib_vector_search/src/tree_finder.cpp

@@ -1,11 +1,11 @@
 #include "tree_finder.h"
 
-using std::string, std::string_view, std::forward_list;
+using std::string, std::string_view;
 
 void SearchTreeNode::insert(string_view partial_word,
                             const string *original_word) {
   if (partial_word.empty()) {
-    words_.push_front(original_word);
+    words_.push_back(original_word);
   } else {
     children_[partial_word.front()].insert(
         string_view(partial_word).substr(1, partial_word.length()),
@@ -26,10 +26,12 @@ const SearchTreeNode *SearchTreeNode::find(string_view search_term) const {
   return nullptr;
 }
 
-forward_list<const string *> SearchTreeNode::words() const {
+WordRefList SearchTreeNode::words() const {
-  forward_list<const string *> results(words_);
+  WordRefList results(words_);
   for (const auto &child : children_) {
-    results.merge(child.second.words());
+    auto child_words = child.second.words();
+    std::move(child_words.begin(), child_words.end(),
+              std::back_inserter(results));
   }
 
   return results;
@@ -43,8 +45,7 @@ SearchTree::SearchTree(const WordList &word_list) {
 
 TreeFinder::TreeFinder(const WordList &word_list) : search_tree_(word_list) {}
 
-forward_list<const string *>
+WordRefList TreeFinder::find_prefix(string_view search_term) const {
-TreeFinder::find_prefix(string_view search_term) const {
   const auto *result_node = search_tree_.find(search_term);
   if (result_node == nullptr) {
     return {};

lib_vector_search/src/word_list.cpp

@@ -25,6 +25,19 @@ WordList &WordList::shuffle() {
   return *this;
 }
 
+WordList WordList::oneCap() {
+  const static std::string charset_ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  WordList word_list;
+  word_list.reserve(charset_.length());
+
+  for (auto char_1 : charset_) {
+    word_list.emplace_back(std::initializer_list<char>({char_1}));
+  }
+
+  return word_list;
+};
+
 WordList WordList::fourCaps() {
   const static std::string charset_ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
@@ -58,22 +71,24 @@ WordList WordList::fromFile(const std::filesystem::path &path) {
   return word_list;
 }
 
-void WordList::find_prefix_in_range(
+void WordList::find_prefix_in_range(const WordList &word_list,
-    const WordList &word_list, const std::string_view &search_prefix,
+                                    const std::string_view &search_prefix,
-    size_t start_index, size_t end_index,
+                                    size_t start_index, size_t end_index,
-    std::forward_list<const std::string *> &result, std::mutex &result_mutex) {
+                                    WordRefList &result,
-  std::forward_list<const std::string *> local_results;
+                                    std::mutex &result_mutex) {
+  WordRefList local_results;
 
   for (size_t index = start_index; index < end_index; ++index) {
     const auto &current_word = word_list[index];
     if (current_word.starts_with(search_prefix)) {
-      local_results.push_front(&current_word);
+      local_results.push_back(&current_word);
     }
   }
 
   if (!local_results.empty()) {
     const std::lock_guard<std::mutex> lock(result_mutex);
-    result.merge(local_results);
+    std::move(local_results.begin(), local_results.end(),
+              std::back_inserter(result));
   }
 };
 
@@ -83,21 +98,23 @@ WordRefList::WordRefList(const WordList &source) {
   }
 }
 
-void WordRefList::find_prefix_in_range(
+void WordRefList::find_prefix_in_range(const WordRefList &word_list,
-    const WordRefList &word_list, const std::string_view &search_prefix,
+                                       const std::string_view &search_prefix,
-    size_t start_index, size_t end_index,
+                                       size_t start_index, size_t end_index,
-    std::forward_list<const std::string *> &result, std::mutex &result_mutex) {
+                                       WordRefList &result,
-  std::forward_list<const std::string *> local_results;
+                                       std::mutex &result_mutex) {
+  WordRefList local_results;
 
   for (size_t index = start_index; index < end_index; ++index) {
     const auto *current_word = word_list[index];
     if (current_word->starts_with(search_prefix)) {
-      local_results.push_front(current_word);
+      local_results.push_back(current_word);
     }
   }
 
   if (!local_results.empty()) {
     const std::lock_guard<std::mutex> lock(result_mutex);
-    result.merge(local_results);
+    std::move(local_results.begin(), local_results.end(),
+              std::back_inserter(result));
   }
 };

vector_search_cli/main.cpp

@@ -55,13 +55,12 @@ int main(int argc, char *argv[]) {
 
   auto word_list = generate_word_list(5);
 
-  test_finder<BucketFinder>(word_list, "bucket finder");
-
   test_finder<LinearFinder>(word_list, "linear finder");
   test_finder<SortedLinearFinder>(word_list, "sorted linear finder");
   test_finder<ParallelFinder>(word_list, "parallel finder");
   test_finder<TreeFinder>(word_list, "tree finder");
   test_finder<GroupedFinder>(word_list, "grouped finder");
+  test_finder<BucketFinder>(word_list, "bucket finder");
 
   return EXIT_SUCCESS;
 }