Migrate boost variant to std variant (KeyviDev#342)

Get rid of boost::variant in favor of std::variant.

Author: hendrikmuhs

keyvi/bin/keyviinspector/keyviinspector.cpp

@@ -26,8 +26,7 @@
 #include <iostream>
 #include <string>
 
-#include <boost/lexical_cast.hpp>
-#include <boost/program_options.hpp>
+#include <boost/program_options.hpp>  // NOLINT(misc-include-cleaner)
 #include <boost/program_options/options_description.hpp>
 #include <boost/program_options/positional_options.hpp>
 #include <boost/program_options/value_semantic.hpp>
@@ -59,25 +58,6 @@ void dump(const std::string& input, const std::string& output, bool keys_only =
   out_stream.close();
 }
 
-void dump_with_attributes(const std::string& input, const std::string& output) {
-  keyvi::dictionary::fsa::automata_t const automata(new keyvi::dictionary::fsa::Automata(input));
-  keyvi::dictionary::fsa::EntryIterator it(automata);
-  keyvi::dictionary::fsa::EntryIterator const end_it = keyvi::dictionary::fsa::EntryIterator();
-
-  std::ofstream out_stream(output);
-
-  while (it != end_it) {
-    it.WriteKey(out_stream);
-
-    out_stream << "\t";
-
-    out_stream << it.GetValueAsAttributeVector()->at("value");
-    out_stream << "\n";
-    ++it;
-  }
-  out_stream.close();
-}
-
 void print_statistics(const std::string& input) {
   keyvi::dictionary::fsa::automata_t const automata(new keyvi::dictionary::fsa::Automata(input));
   std::cout << automata->GetStatistics() << '\n';
@@ -121,7 +101,6 @@ int main(int argc, char** argv) {
     output_file = vm["output-file"].as<std::string>();
 
     dump(input_file, output_file, key_only);
-    // dump_with_attributes (input_file, output_file);
     return 0;
   }
 

keyvi/include/keyvi/dictionary/completion/forward_backward_completion.h

@@ -33,7 +33,6 @@
 #include <vector>
 
 #include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include "keyvi/dictionary/completion/prefix_completion.h"
 #include "keyvi/dictionary/util/bounded_priority_queue.h"
@@ -72,8 +71,8 @@ class ForwardBackwardCompletion final {
     util::BoundedPriorityQueue<uint32_t> best_scores(2 * number_of_results);
     std::vector<match_t> results;
 
-    for (auto match : forward_completions_.GetCompletions(query, number_of_results)) {
-      uint32_t weight = boost::lexical_cast<uint32_t>(match->GetAttribute("weight"));
+    for (auto& match : forward_completions_.GetCompletions(query, number_of_results)) {
+      uint32_t weight = match->GetWeight();
 
       // put the weight into the priority queue
       best_scores.Put(weight);
@@ -109,8 +108,8 @@ class ForwardBackwardCompletion final {
               best_scores.Back());
 
         uint32_t last_weight = 0;
-        for (auto match : backward_completions_.GetCompletions(phrase.c_str(), number_of_results)) {
-          uint32_t weight = boost::lexical_cast<uint32_t>(match->GetAttribute("weight"));
+        for (auto& match : backward_completions_.GetCompletions(phrase.c_str(), number_of_results)) {
+          uint32_t weight = match->GetWeight();
 
           if (weight < best_scores.Back()) {
             TRACE("Skip Backward, score to low %d", weight);
@@ -160,15 +159,15 @@ class ForwardBackwardCompletion final {
 
         // reuse results vector
         results.clear();
-        for (auto match : backward_completions_.GetCompletions(phrase.c_str(), number_of_results)) {
+        for (auto& match : backward_completions_.GetCompletions(phrase.c_str(), number_of_results)) {
           std::string matched_string = match->GetMatchedString();
           std::reverse(matched_string.begin(), matched_string.end());
           // if the original query had a space at the end, this result should as well
           if (last_character_is_space) {
             matched_string.append(" ");
           }
 
-          uint32_t weight = boost::lexical_cast<uint32_t>(match->GetAttribute("weight"));
+          uint32_t weight = match->GetWeight();
           match->SetScore(weight);
           match->SetMatchedString(matched_string);
 
@@ -195,9 +194,9 @@ class ForwardBackwardCompletion final {
             }
 
             // match forward with this
-            for (auto match_forward :
+            for (auto& match_forward :
                  forward_completions_.GetCompletions(m->GetMatchedString().c_str(), number_of_results)) {
-              uint32_t weight = boost::lexical_cast<uint32_t>(match_forward->GetAttribute("weight"));
+              uint32_t weight = match_forward->GetWeight();
 
               if (weight < best_scores.Back()) {
                 TRACE("Skip Backward forward,  score to low %d", weight);

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

@@ -27,11 +27,11 @@
 
 #include <memory>
 #include <string>
+#include <variant>
 
 #include <boost/container/flat_map.hpp>
 #include <boost/interprocess/file_mapping.hpp>
 #include <boost/interprocess/mapped_region.hpp>
-#include <boost/variant.hpp>
 
 #include "keyvi/compression/compression_selector.h"
 #include "keyvi/dictionary/dictionary_merger_fwd.h"
@@ -60,7 +60,7 @@ struct ValueStoreComponents {};
  *
  * The following types/constants/methods (incomplete list) are required:
  *
- * typedef {type} value_t;
+ * using value_t = {type};
  * static const {type} no_value = 0;
  *
  * uint64_t GetValue(value_t value, bool* no_minimization)
@@ -85,8 +85,9 @@ struct ValueStoreComponents {};
  */
 class IValueStoreReader {
  public:
-  typedef boost::container::flat_map<std::string, boost::variant<std::string, int, double, bool>> attributes_raw_t;
-  typedef std::shared_ptr<attributes_raw_t> attributes_t;
+  using attribute_t = std::variant<std::string, int, double, bool>;
+  using attributes_raw_t = boost::container::flat_map<std::string, attribute_t>;
+  using attributes_t = std::shared_ptr<attributes_raw_t>;
 
   /**
    * Default constructor. Override if the value store implementation requires extra data.

keyvi/include/keyvi/dictionary/match.h

@@ -28,9 +28,9 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include <boost/container/flat_map.hpp>
-#include <boost/variant.hpp>
 
 #include "keyvi/compression/compression_strategy.h"
 #include "keyvi/dictionary/fsa/automata.h"
@@ -56,22 +56,9 @@ keyvi::dictionary::match_t FirstFilteredMatch(const MatcherT&, const DeletedT&);
 }  // namespace index
 namespace dictionary {
 
-#ifdef Py_PYTHON_H
-class attributes_visitor : public boost::static_visitor<PyObject*> {
- public:
-  PyObject* operator()(int i) const { return PyLong_FromLong(i); }
-
-  PyObject* operator()(double i) const { return PyFloat_FromDouble(i); }
-
-  PyObject* operator()(bool i) const { return i ? Py_True : Py_False; }
-
-  PyObject* operator()(const std::string& str) const { return PyUnicode_FromString(str.c_str()); }
-};
-#endif
-
 struct Match {
-  typedef std::shared_ptr<boost::container::flat_map<std::string, boost::variant<std::string, int, double, bool>>>
-      attributes_t;
+  using attribute_t = std::variant<std::string, int, double, bool>;
+  using attributes_t = std::shared_ptr<boost::container::flat_map<std::string, attribute_t>>;
 
   Match(size_t a, size_t b, const std::string& matched_item, uint32_t score = 0, uint32_t weight = 0)
       : start_(a), end_(b), matched_item_(matched_item), raw_value_(), score_(score) {
@@ -139,11 +126,27 @@ struct Match {
 #ifdef Py_PYTHON_H
   PyObject* GetAttributePy(const std::string& key) {
     auto result = GetAttribute(key);
-    return boost::apply_visitor(attributes_visitor(), result);
+
+    return std::visit(
+        [](auto&& arg) {
+          using T = std::decay_t<decltype(arg)>;
+          if constexpr (std::is_same_v<T, bool>) {
+            return arg ? Py_True : Py_False;
+          } else if constexpr (std::is_same_v<T, int>) {
+            return PyLong_FromLong(arg);
+          } else if constexpr (std::is_same_v<T, double>) {
+            return PyFloat_FromDouble(arg);
+          } else if constexpr (std::is_same_v<T, std::string>) {
+            return PyUnicode_FromString(arg.c_str());
+          }
+          // not reachable
+          throw std::runtime_error("unexpected attribute type");
+        },
+        result);
   }
 #endif
 
-  const boost::variant<std::string, int, double, bool>& GetAttribute(const std::string& key) {
+  const attribute_t& GetAttribute(const std::string& key) {
     // lazy creation
     if (!attributes_) {
       if (fsa_) {

keyvi/include/keyvi/index/internal/index_settings.h

@@ -25,9 +25,9 @@
 #define KEYVI_INDEX_INTERNAL_INDEX_SETTINGS_H_
 
 #include <string>
+#include <tuple>
 #include <unordered_map>
-
-#include <boost/variant.hpp>
+#include <variant>
 
 #include "keyvi/index/constants.h"
 #include "keyvi/index/internal/index_auto_config.h"
@@ -77,24 +77,24 @@ class IndexSettings final {
     }
   }
 
-  const std::string& GetKeyviMergerBin() const { return boost::get<std::string>(settings_.at(KEYVIMERGER_BIN)); }
+  const std::string& GetKeyviMergerBin() const { return std::get<std::string>(settings_.at(KEYVIMERGER_BIN)); }
 
-  const size_t GetMaxSegments() const { return boost::get<size_t>(settings_.at(INDEX_MAX_SEGMENTS)); }
+  const size_t GetMaxSegments() const { return std::get<size_t>(settings_.at(INDEX_MAX_SEGMENTS)); }
 
   const size_t GetSegmentCompileKeyThreshold() const {
-    return boost::get<size_t>(settings_.at(SEGMENT_COMPILE_KEY_THRESHOLD));
+    return std::get<size_t>(settings_.at(SEGMENT_COMPILE_KEY_THRESHOLD));
   }
 
-  const size_t GetMaxConcurrentMerges() const { return boost::get<size_t>(settings_.at(MAX_CONCURRENT_MERGES)); }
+  const size_t GetMaxConcurrentMerges() const { return std::get<size_t>(settings_.at(MAX_CONCURRENT_MERGES)); }
 
-  const size_t GetRefreshInterval() const { return boost::get<size_t>(settings_.at(INDEX_REFRESH_INTERVAL)); }
+  const size_t GetRefreshInterval() const { return std::get<size_t>(settings_.at(INDEX_REFRESH_INTERVAL)); }
 
   const size_t GetSegmentExternalMergeKeyThreshold() const {
-    return boost::get<size_t>(settings_.at(SEGMENT_EXTERNAL_MERGE_KEY_THRESHOLD));
+    return std::get<size_t>(settings_.at(SEGMENT_EXTERNAL_MERGE_KEY_THRESHOLD));
   }
 
  private:
-  std::unordered_map<std::string, boost::variant<std::string, size_t>> settings_;
+  std::unordered_map<std::string, std::variant<std::string, size_t>> settings_;
 };
 
 } /* namespace internal */

keyvi/tests/keyvi/dictionary/dictionary_test.cpp

@@ -23,6 +23,10 @@
  *      Author: hendrik
  */
 
+#include <string>
+#include <tuple>
+#include <vector>
+
 #include <boost/filesystem.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -71,7 +75,7 @@ BOOST_AUTO_TEST_CASE(DictGet) {
   bool matched = false;
   for (auto m : d->Get("test")) {
     BOOST_CHECK_EQUAL("test", m->GetMatchedString());
-    BOOST_CHECK_EQUAL(std::string("22"), boost::get<std::string>(m->GetAttribute("weight")));
+    BOOST_CHECK_EQUAL(std::string("22"), std::get<std::string>(m->GetAttribute("weight")));
     matched = true;
   }
   BOOST_CHECK(matched);
@@ -84,7 +88,7 @@ BOOST_AUTO_TEST_CASE(DictGet) {
   BOOST_CHECK(!matched);
 
   auto m = (*d)["test"];
-  BOOST_CHECK_EQUAL("22", boost::get<std::string>(m->GetAttribute("weight")));
+  BOOST_CHECK_EQUAL("22", std::get<std::string>(m->GetAttribute("weight")));
 }
 
 BOOST_AUTO_TEST_CASE(DictLookup) {
@@ -99,23 +103,23 @@ BOOST_AUTO_TEST_CASE(DictLookup) {
   bool matched = false;
   for (auto m : d->Lookup("nude")) {
     BOOST_CHECK_EQUAL("nude", m->GetMatchedString());
-    BOOST_CHECK_EQUAL("22", boost::get<std::string>(m->GetAttribute("weight")));
+    BOOST_CHECK_EQUAL("22", std::get<std::string>(m->GetAttribute("weight")));
     matched = true;
   }
   BOOST_CHECK(matched);
 
   matched = false;
   for (auto m : d->Lookup("nude ")) {
     BOOST_CHECK_EQUAL("nude", m->GetMatchedString());
-    BOOST_CHECK_EQUAL("22", boost::get<std::string>(m->GetAttribute("weight")));
+    BOOST_CHECK_EQUAL("22", std::get<std::string>(m->GetAttribute("weight")));
     matched = true;
   }
   BOOST_CHECK(matched);
 
   matched = false;
   for (auto m : d->Lookup("nude at work")) {
     BOOST_CHECK_EQUAL("nude", m->GetMatchedString());
-    BOOST_CHECK_EQUAL("22", boost::get<std::string>(m->GetAttribute("weight")));
+    BOOST_CHECK_EQUAL("22", std::get<std::string>(m->GetAttribute("weight")));
     matched = true;
   }
   BOOST_CHECK(matched);
@@ -207,7 +211,7 @@ BOOST_AUTO_TEST_CASE(DictGetZerobyte) {
   bool matched = false;
   for (auto m : d->Get(std::string("\0test", 5))) {
     BOOST_CHECK_EQUAL(std::string("\0test", 5), m->GetMatchedString());
-    BOOST_CHECK_EQUAL(std::string("22"), boost::get<std::string>(m->GetAttribute("weight")));
+    BOOST_CHECK_EQUAL(std::string("22"), std::get<std::string>(m->GetAttribute("weight")));
     matched = true;
   }
   BOOST_CHECK(matched);
@@ -220,7 +224,7 @@ BOOST_AUTO_TEST_CASE(DictGetZerobyte) {
   BOOST_CHECK(!matched);
 
   auto m = (*d)[std::string("\0test", 5)];
-  BOOST_CHECK_EQUAL("22", boost::get<std::string>(m->GetAttribute("weight")));
+  BOOST_CHECK_EQUAL("22", std::get<std::string>(m->GetAttribute("weight")));
 }
 
 BOOST_AUTO_TEST_CASE(DictGetPrefixCompletion) {