Update core header files to support C++17 as well (NVIDIA#27)

Signed-off-by: Ben Howe <[email protected]>

libs/core/include/cuda-qx/core/extension_point.h

@@ -10,6 +10,7 @@
 
 #include <functional>
 #include <memory>
+#include <stdexcept>
 #include <unordered_map>
 
 namespace cudaqx {

libs/core/include/cuda-qx/core/heterogeneous_map.h

@@ -104,13 +104,16 @@ class heterogeneous_map {
     // we have a value of type int, but request here is std::size_t.
     // Handle that case, by getting T's map of related types, and checking
     // if any of them are valid.
-    using RelatedTypes =
-        typename RelatedTypesMap<std::remove_cvref_t<T>>::types;
+    using RelatedTypes = typename RelatedTypesMap<
+        std::remove_cv_t<std::remove_reference_t<T>>>::types;
     std::optional<T> opt;
     cudaqx::tuple_for_each(RelatedTypes(), [&](auto &&el) {
       if (!opt.has_value() &&
-          isCastable<std::remove_cvref_t<decltype(el)>>(iter->second))
-        opt = std::any_cast<std::remove_cvref_t<decltype(el)>>(iter->second);
+          isCastable<std::remove_cv_t<std::remove_reference_t<decltype(el)>>>(
+              iter->second))
+        opt = std::any_cast<
+            std::remove_cv_t<std::remove_reference_t<decltype(el)>>>(
+            iter->second);
     });
 
     if (opt.has_value())
@@ -185,10 +188,12 @@ class heterogeneous_map {
   /// @brief Check if the map contains a key
   /// @param key The key to check
   /// @return true if the key exists, false otherwise
-  bool contains(const std::string &key) const { return items.contains(key); }
+  bool contains(const std::string &key) const {
+    return items.find(key) != items.end();
+  }
   bool contains(const std::vector<std::string> &keys) const {
     for (auto &key : keys)
-      if (items.contains(key))
+      if (items.find(key) != items.end())
         return true;
 
     return false;

libs/core/include/cuda-qx/core/tensor.h

@@ -13,7 +13,9 @@
 
 namespace cudaqx {
 
-/// @brief A tensor class implementing the PIMPL idiom.
+/// @brief A tensor class implementing the PIMPL idiom. The flattened data is
+/// stored where the strides grow from right to left (similar to a
+/// multi-dimensional C array).
 template <typename Scalar = std::complex<double>>
 class tensor {
 private:
@@ -35,7 +37,7 @@ class tensor {
 
 public:
   /// @brief Type alias for the scalar type used in the tensor
-  using scalar_type = details::tensor_impl<Scalar>::scalar_type;
+  using scalar_type = typename details::tensor_impl<Scalar>::scalar_type;
   static constexpr auto ScalarAsString = type_to_string<Scalar>();
 
   /// @brief Construct an empty tensor
@@ -54,7 +56,7 @@ class tensor {
                 .release())) {}
 
   /// @brief Construct a tensor with the given data and shape
-  /// @param data Pointer to the tensor data
+  /// @param data Pointer to the tensor data. This takes ownership of the data.
   /// @param shape The shape of the tensor
   tensor(const scalar_type *data, const std::vector<std::size_t> &shape)
       : pimpl(std::shared_ptr<details::tensor_impl<Scalar>>(