Use specific types.

andreiavrammsd · Jun 11, 2023 · 45215e3 · 45215e3
1 parent 0b689e2
commit 45215e3
Show file tree

Hide file tree

Showing 6 changed files with 42 additions and 40 deletions.
diff --git a/README.md b/README.md
@@ -25,18 +25,18 @@ A recursive map that can have any shape and can hold multiple types for keys and
 #include <string>
 #include <utility>
 
-#include "msd/poly_map.hpp"
+#include <msd/poly_map.hpp>
 
 struct visitor {
     template <typename V, typename M>
-    auto operator()(const double key, V&, M&)
+    bool operator()(const double key, V&, M&)
     {
         std::cout << "double = " << key << "\n";
         return true;
     }
 
     template <typename K, typename V, typename M>
-    auto operator()(K& key, V&, M&)
+    bool operator()(K& key, V&, M&)
     {
         std::cout << "other = " << key << "\n";
         return true;

diff --git a/examples/bazel-project/src/main.cpp b/examples/bazel-project/src/main.cpp
@@ -1,6 +1,6 @@
 #include <cassert>
 
-#include "msd/poly_map.hpp"
+#include <msd/poly_map.hpp>
 
 int main()
 {

diff --git a/examples/cmake-project/src/main.cpp b/examples/cmake-project/src/main.cpp
@@ -1,6 +1,6 @@
 #include <cassert>
 
-#include "msd/poly_map.hpp"
+#include <msd/poly_map.hpp>
 
 int main()
 {

diff --git a/examples/lambda_visitor.cpp b/examples/lambda_visitor.cpp
@@ -1,7 +1,7 @@
 #include <iostream>
 #include <string>
 
-#include "msd/poly_map.hpp"
+#include <msd/poly_map.hpp>
 
 // https://en.cppreference.com/w/cpp/utility/variant/visit#Example
 template <class... Ts>
@@ -22,17 +22,17 @@ int main()
     map[1][2][3.1][4.2]["g"] = 199;
 
     const auto lambda_visitor = visitor{
-        [](const double key, auto& value, auto&) {
+        [](const double key, auto& value, auto&) -> bool {
             std::cout << "double key " << key << " " << (value.empty() ? "has no value" : "has a value") << "\n";
             return true;
         },
 
-        [](const std::string& key, auto& value, auto&) {
+        [](const std::string& key, auto& value, auto&) -> bool {
             std::cout << "string key " << key << " " << (value.empty() ? "has no value" : "has a value") << "\n";
             return true;
         },
 
-        [](auto key, auto& value, auto&) {
+        [](auto key, auto& value, auto&) -> bool {
             std::cout << "other key " << key << " " << (value.empty() ? "has no value" : "has a value") << "\n";
             return true;
         },

diff --git a/include/msd/poly_map.hpp b/include/msd/poly_map.hpp
@@ -38,7 +38,7 @@ struct poly_map_value {
      * @throws std::bad_cast if cannot cast stored value to given type.
      */
     template <typename T>
-    [[nodiscard]] auto get() const
+    [[nodiscard]] T get() const
     {
         try {
             return std::any_cast<T>(value_);
@@ -71,10 +71,12 @@ class poly_map {
      *
      * @param v Value to add.
      *
+     * @return Reference to map.
+     *
      * @throws std::bad_alloc or the exception thrown by the assigned value's constructor.
      */
     template <typename T>
-    auto& operator=(T&& v)
+    poly_map& operator=(T&& v)
     {
         value_.set(std::forward<T>(v));
 
@@ -91,7 +93,7 @@ class poly_map {
      * @throws std::out_of_range if key not found.
      */
     template <typename T>
-    [[nodiscard]] auto& at(const T& key)
+    [[nodiscard]] poly_map& at(const T& key)
     {
         return elements_.at(key);
     }
@@ -122,7 +124,7 @@ class poly_map {
      * @throws std::out_of_range if key not found.
      */
     template <typename T, typename... Ts>
-    [[nodiscard]] auto& at(const T& key, const Ts&... keys) const
+    [[nodiscard]] poly_map& at(const T& key, const Ts&... keys) const
     {
         return const_cast<poly_map*>(this)->at(key, keys...);
     }
@@ -137,7 +139,7 @@ class poly_map {
      * @throws std::out_of_range if key not found.
      */
     template <typename T>
-    auto& operator[](const T key)
+    poly_map& operator[](const T key)
     {
         return elements_[key];
     }
@@ -152,7 +154,7 @@ class poly_map {
      * @throws std::bad_cast if cannot cast stored value to given type.
      */
     template <typename T>
-    [[nodiscard]] auto get() const
+    [[nodiscard]] T get() const
     {
         return value_.template get<T>();
     }
@@ -166,7 +168,7 @@ class poly_map {
     void for_each(V&& visitor)
     {
         for (auto& element : elements_) {
-            const auto visit = [this, &visitor, &element](auto& key) {
+            const auto visit = [this, &visitor, &element](auto& key) -> bool {
                 return visitor(key, element.second.value_, elements_);
             };
 

diff --git a/tests/poly_map_test.cpp b/tests/poly_map_test.cpp
@@ -1,12 +1,12 @@
-#include "msd/poly_map.hpp"
+#include <msd/poly_map.hpp>
 
 #include <any>
 #include <limits>
 #include <string>
 #include <tuple>
 #include <vector>
 
-#include "gtest/gtest.h"
+#include <gtest/gtest.h>
 
 using poly_map_type = msd::poly_map<int, double, std::string>;
 
@@ -106,7 +106,7 @@ struct map_visitor {
 
 TEST_F(PolyMapTest, for_each)
 {
-    auto visitor = map_visitor{};
+    map_visitor visitor{};
     map.for_each(visitor);
 
     EXPECT_EQ(visitor.keys.size(), 6);
@@ -125,19 +125,19 @@ TEST_F(PolyMapTest, for_each)
     EXPECT_EQ((visitor.values[4].get<std::pair<int, int>>()), std::make_pair(1, 2));
     EXPECT_EQ(visitor.values[5].get<int>(), 199);
 
-    auto const_visitor = map_visitor{};
-    const_map.for_each(const_visitor);
+    map_visitor visitor_for_const_map {};
+    const_map.for_each(visitor_for_const_map);
 
-    EXPECT_EQ(const_visitor.keys.size(), 6);
-    EXPECT_EQ(const_visitor.values.size(), 6);
+    EXPECT_EQ(visitor_for_const_map.keys.size(), 6);
+    EXPECT_EQ(visitor_for_const_map.values.size(), 6);
 }
 
 struct stop_visitor {
     std::size_t key_count;
     std::size_t value_count;
 
     template <typename K, typename V, typename M>
-    auto operator()(K&, V&, M&)
+    bool operator()(K&, V&, M&)
     {
         ++key_count;
         ++value_count;
@@ -147,13 +147,13 @@ struct stop_visitor {
 
 TEST_F(PolyMapTest, for_each_stop)
 {
-    auto visitor = stop_visitor{};
+    stop_visitor visitor{};
     map.for_each(visitor);
 
     EXPECT_EQ(visitor.key_count, 1);
     EXPECT_EQ(visitor.value_count, 1);
 
-    auto const_visitor = stop_visitor{};
+    stop_visitor const_visitor{};
     const_map.for_each(const_visitor);
 
     EXPECT_EQ(const_visitor.key_count, 1);
@@ -167,22 +167,22 @@ struct passed_map_visitor {
     bool operator()(const std::string& key, V&, M& map)
     {
         if (key == "f") {
-            auto passed_map_ptr = static_cast<void*>(&map);
-            auto test_map_ptr = static_cast<void*>(&test_map.at(1).at(2).at(3.1));
+            const auto passed_map_ptr = static_cast<void*>(&map);
+            const auto test_map_ptr = static_cast<void*>(&test_map.at(1).at(2).at(3.1));
             EXPECT_EQ(passed_map_ptr, test_map_ptr);
 
-            auto passed_map_value = map[key].template get<int>();
-            auto test_map_value = test_map.at(1).at(2).at(3.1).at(key).get<int>();
+            const auto passed_map_value = map[key].template get<int>();
+            const auto test_map_value = test_map.at(1).at(2).at(3.1).at(key).get<int>();
             EXPECT_EQ(passed_map_value, test_map_value);
         }
 
         if (key == "g") {
-            auto passed_map_ptr = static_cast<void*>(&map);
-            auto test_map_ptr = static_cast<void*>(&test_map.at(1).at(2).at(3.1).at(4.2));
+            const auto passed_map_ptr = static_cast<void*>(&map);
+            const auto test_map_ptr = static_cast<void*>(&test_map.at(1).at(2).at(3.1).at(4.2));
             EXPECT_EQ(passed_map_ptr, test_map_ptr);
 
-            auto passed_map_value = map[key].template get<std::pair<int, int>>();
-            auto test_map_value = test_map.at(1).at(2).at(3.1).at(4.2).at(key).get<std::pair<int, int>>();
+            const auto passed_map_value = map[key].template get<std::pair<int, int>>();
+            const auto test_map_value = test_map.at(1).at(2).at(3.1).at(4.2).at(key).get<std::pair<int, int>>();
             EXPECT_EQ(passed_map_value, test_map_value);
         }
 
@@ -206,7 +206,7 @@ struct element_visitor {
     std::vector<std::any>& keys;
 
     template <typename K, typename V, typename M>
-    auto operator()(const K& key, V&, M&)
+    bool operator()(const K& key, V&, M&)
     {
         keys.emplace_back(key);
         return true;
@@ -241,17 +241,17 @@ TEST_F(PolyMapTest, for_each_element)
 
 TEST_F(PolyMapTest, for_each_stop_element)
 {
-    auto visitor = stop_visitor{};
+    stop_visitor visitor{};
     map[1].for_each(visitor);
 
     EXPECT_EQ(visitor.key_count, 1);
     EXPECT_EQ(visitor.value_count, 1);
 
-    auto const_visitor = stop_visitor{};
-    const_map.for_each(const_visitor);
+    stop_visitor visitor_for_const_map{};
+    const_map.for_each(visitor_for_const_map);
 
-    EXPECT_EQ(const_visitor.key_count, 1);
-    EXPECT_EQ(const_visitor.value_count, 1);
+    EXPECT_EQ(visitor_for_const_map.key_count, 1);
+    EXPECT_EQ(visitor_for_const_map.value_count, 1);
 }
 
 TEST_F(PolyMapTest, empty)