Handles are valid upon construction

Author: knoepfel

phlex/model/handle.hpp

@@ -30,31 +30,22 @@ namespace phlex::experimental {
     using const_reference = value_type const&;
     using const_pointer = value_type const*;
 
-    handle() = default;
-
     template <typename U>
-    explicit handle(product<U> const& prod, level_id const& id = level_id::base())
+    explicit handle(U const* prod, level_id const& id)
       requires detail::same_handle_type<T, U>
-      : rep_{&prod.obj}, id_{&id}
+      : rep_{prod}, id_{&id}
     {
     }
 
-    explicit handle(std::variant<const_pointer, err_t> maybe_product, level_id const& id) :
-      rep_{std::move(maybe_product)}, id_{&id}
+    template <typename U>
+    explicit handle(product<U> const& prod, level_id const& id = level_id::base())
+      requires detail::same_handle_type<T, U>
+      : handle{&prod.obj, id}
     {
     }
 
-    explicit handle(std::string err_msg, level_id const& id) : rep_{std::move(err_msg)}, id_{&id} {}
-
-    const_pointer operator->() const
-    {
-      if (auto const* err = get_if<err_t>(&rep_)) {
-        throw std::runtime_error(*err);
-      }
-      return get<const_pointer>(rep_);
-    }
-    [[nodiscard]] const_reference operator*() const { return *operator->(); }
-    explicit operator bool() const noexcept { return get_if<const_pointer>(&rep_) != nullptr; }
+    const_pointer operator->() const noexcept { return rep_; }
+    [[nodiscard]] const_reference operator*() const noexcept { return *operator->(); }
     operator const_reference() const noexcept { return operator*(); }
     operator const_pointer() const noexcept { return operator->(); }
 
@@ -71,9 +62,8 @@ namespace phlex::experimental {
     }
 
   private:
-    std::variant<const_pointer, err_t> rep_{"Cannot dereference empty handle of type '" +
-                                            boost::core::demangle(typeid(T).name()) + "'."};
-    class level_id const* id_;
+    const_pointer rep_{nullptr};
+    class level_id const* id_{nullptr};
   };
 
   template <typename T>

phlex/model/products.cpp

@@ -13,12 +13,12 @@ namespace phlex::experimental {
   products::const_iterator products::begin() const noexcept { return products_.begin(); }
   products::const_iterator products::end() const noexcept { return products_.end(); }
 
-  std::string products::error_message(std::string const& product_name,
-                                      char const* requested_type,
-                                      char const* available_type)
+  void products::throw_mismatched_type(std::string const& product_name,
+                                       char const* requested_type,
+                                       char const* available_type)
   {
-    return "Cannot get product '" + product_name + "' with type '" +
-           boost::core::demangle(requested_type) + "' -- must specify type '" +
-           boost::core::demangle(available_type) + "'.";
+    throw std::runtime_error("Cannot get product '" + product_name + "' with type '" +
+                             boost::core::demangle(requested_type) + "' -- must specify type '" +
+                             boost::core::demangle(available_type) + "'.");
   }
 }

phlex/model/products.hpp

@@ -69,11 +69,11 @@ namespace phlex::experimental {
     }
 
     template <typename T>
-    std::variant<T const*, std::string> get(std::string const& product_name) const
+    T const* get(std::string const& product_name) const
     {
       auto it = products_.find(product_name);
       if (it == cend(products_)) {
-        return "No product exists with the name '" + product_name + "'.";
+        throw std::runtime_error("No product exists with the name '" + product_name + "'.");
       }
 
       // Should be able to use dynamic_cast a la:
@@ -89,17 +89,18 @@ namespace phlex::experimental {
       if (std::strcmp(typeid(T).name(), available_product->type().name()) == 0) {
         return &reinterpret_cast<product<T> const*>(available_product)->obj;
       }
-      return error_message(product_name, typeid(T).name(), available_product->type().name());
+
+      throw_mismatched_type(product_name, typeid(T).name(), available_product->type().name());
     }
 
     bool contains(std::string const& product_name) const;
     const_iterator begin() const noexcept;
     const_iterator end() const noexcept;
 
   private:
-    static std::string error_message(std::string const& product_name,
-                                     char const* requested_type,
-                                     char const* available_type);
+    static void throw_mismatched_type [[noreturn]] (std::string const& product_name,
+                                                    char const* requested_type,
+                                                    char const* available_type);
 
     collection_t products_;
   };

test/product_handle.cpp

@@ -34,12 +34,6 @@ TEST_CASE("Can only create handles with compatible types", "[data model]")
 
 TEST_CASE("Handle type conversions (run-time checks)", "[data model]")
 {
-  handle<double> empty;
-  CHECK(not empty);
-  CHECK_THROWS_WITH(
-    *empty,
-    Catch::Matchers::ContainsSubstring("Cannot dereference empty handle of type 'double'."));
-
   product<int> const number{3};
   handle const h{number};
   CHECK(handle<int const>{number} == h);

test/product_store.cpp

@@ -21,12 +21,9 @@ TEST_CASE("Product store insertion", "[data model]")
     Catch::Matchers::ContainsSubstring(
       "Cannot get product 'number' with type 'double' -- must specify type 'int'."));
 
-  auto invalid_handle = store->get_handle<int>("wrong_key");
-  CHECK(!invalid_handle);
   auto const matcher =
     Catch::Matchers::ContainsSubstring("No product exists with the name 'wrong_key'.");
-  CHECK_THROWS_WITH(*invalid_handle, matcher);
-  CHECK_THROWS_WITH(invalid_handle.operator->(), matcher);
+  CHECK_THROWS_WITH(store->get_handle<int>("wrong_key"), matcher);
 
   CHECK(store->get_product<int>("number") == number);