diff --git a/docs/changelog/better-unknown-type-reporting.md b/docs/changelog/better-unknown-type-reporting.md new file mode 100644 index 0000000000000000000000000000000000000000..6a867ade2d1dfc5cabfa661d1d413c4fad11c87a --- /dev/null +++ b/docs/changelog/better-unknown-type-reporting.md @@ -0,0 +1,14 @@ +# Improve type reporting in `UnknownArrayHandle` + +Added features with reporting types with `UnknownArrayHandle`. First, added +a method named `GetArrayTypeName` that returns a string containing the type +of the contained array. There were already methods `GetValueType` and +`GetStorageType`, but this provides a convenience to get the whole name in +one go. + +Also improved the reporting when an `AsArrayHandle` call failed. Before, +the thrown method just reported that the `UnknownArrayHandle` could not be +converted to the given type. Now, it also reports the type actually held by +the `UnknownArrayHandle` so the user can better understand why the +conversion failed. + diff --git a/docs/changelog/type-index-names.md b/docs/changelog/type-index-names.md new file mode 100644 index 0000000000000000000000000000000000000000..599d72248e9f981d7f466504b659d6ced23616e7 --- /dev/null +++ b/docs/changelog/type-index-names.md @@ -0,0 +1,11 @@ +# Enable `TypeToString` for `type_info` + +VTK-m contains a helpful method named `vtkm::cont::TypeToString` that +either takes a type as a template argument or a `std::type_info` object and +returns a human-readable string for that type. + +The standard C++ library has an alternate for `std::type_info` named +`std::type_index`, which has the added ability to be used in a container +like `set` or `map`. The `TypeToString` overloads have been extended to +also accept a `std::type_info` and report the name of the type stored in it +(rather than the name of `type_info` itself). diff --git a/vtkm/cont/ArrayRangeCompute.cxx b/vtkm/cont/ArrayRangeCompute.cxx index 142b6e3160a6a01ad42eec647d32112db9ac2039..8ff99fdd2f221b613090b258b26da6d12b0c14bc 100644 --- a/vtkm/cont/ArrayRangeCompute.cxx +++ b/vtkm/cont/ArrayRangeCompute.cxx @@ -237,7 +237,7 @@ vtkm::cont::ArrayHandle ArrayRangeCompute(const vtkm::cont::Unknown return ArrayRangeCompute(array.AsArrayHandle(), device); } } - catch (vtkm::cont::ErrorBadValue&) + catch (vtkm::cont::ErrorBadType&) { // If a cast/call failed, try falling back to a more general implementation. } diff --git a/vtkm/cont/Logging.cxx b/vtkm/cont/Logging.cxx index 6bbbb531b3fb97e02624e3eadfa70021b3f6ddaf..27dc1a1462fd9c3686ac3ade090c4dc6ad88bb4c 100644 --- a/vtkm/cont/Logging.cxx +++ b/vtkm/cont/Logging.cxx @@ -298,5 +298,24 @@ std::string GetLogLevelName(LogLevel level) using T = std::underlying_type::type; return std::to_string(static_cast(level)); } + +VTKM_CONT std::string TypeToString(const std::type_info& t) +{ +#ifdef VTKM_ENABLE_LOGGING + return loguru::demangle(t.name()).c_str(); +#else // VTKM_ENABLE_LOGGING + return t.name(); +#endif // VTKM_ENABLE_LOGGING +} + +VTKM_CONT std::string TypeToString(const std::type_index& t) +{ +#ifdef VTKM_ENABLE_LOGGING + return loguru::demangle(t.name()).c_str(); +#else // VTKM_ENABLE_LOGGING + return t.name(); +#endif // VTKM_ENABLE_LOGGING +} + } } // end namespace vtkm::cont diff --git a/vtkm/cont/Logging.h b/vtkm/cont/Logging.h index bbf7c291632a8875acf81c5c55772314377bef09..2017cc448acdfc8099bd5ab7ff7b1469f61e7554 100644 --- a/vtkm/cont/Logging.h +++ b/vtkm/cont/Logging.h @@ -39,6 +39,7 @@ #endif // VTKM_ENABLE_LOGGING #include +#include #include /// \file Logging.h @@ -472,14 +473,8 @@ VTKM_CONT inline std::string GetSizeString(T&& bytes, int prec = 2) * enabled and the platform supports it, the type name will also be demangled. * @{ */ -inline VTKM_CONT std::string TypeToString(const std::type_info& t) -{ -#ifdef VTKM_ENABLE_LOGGING - return loguru::demangle(t.name()).c_str(); -#else // VTKM_ENABLE_LOGGING - return t.name(); -#endif // VTKM_ENABLE_LOGGING -} +VTKM_CONT_EXPORT VTKM_CONT std::string TypeToString(const std::type_info& t); +VTKM_CONT_EXPORT VTKM_CONT std::string TypeToString(const std::type_index& t); template inline VTKM_CONT std::string TypeToString() { diff --git a/vtkm/cont/UnknownArrayHandle.cxx b/vtkm/cont/UnknownArrayHandle.cxx index e743e4ff42dd763ef9a1249e6b6586caa9c28dd8..1397f47f800112dd03001e71a43ffb0b279d6c47 100644 --- a/vtkm/cont/UnknownArrayHandle.cxx +++ b/vtkm/cont/UnknownArrayHandle.cxx @@ -201,6 +201,19 @@ VTKM_CONT std::string UnknownArrayHandle::GetStorageTypeName() const } } +VTKM_CONT std::string UnknownArrayHandle::GetArrayTypeName() const +{ + if (this->Container) + { + return "vtkm::cont::ArrayHandle<" + this->GetValueTypeName() + ", " + + this->GetStorageTypeName() + ">"; + } + else + { + return ""; + } +} + VTKM_CONT vtkm::Id UnknownArrayHandle::GetNumberOfValues() const { if (this->Container) @@ -297,7 +310,7 @@ VTKM_CONT_EXPORT void ThrowCastAndCallException(const vtkm::cont::UnknownArrayHa "Array: "; ref.PrintSummary(out); out << "TypeList: " << vtkm::cont::TypeToString(type) << "\n"; - throw vtkm::cont::ErrorBadValue(out.str()); + throw vtkm::cont::ErrorBadType(out.str()); } } // namespace detail diff --git a/vtkm/cont/UnknownArrayHandle.h b/vtkm/cont/UnknownArrayHandle.h index d27b44309dcbdba3b10f753cdf11060831e2a5b5..b6c224572f799b8d6b67ee2b9c724dd57bc6890a 100644 --- a/vtkm/cont/UnknownArrayHandle.h +++ b/vtkm/cont/UnknownArrayHandle.h @@ -447,6 +447,13 @@ public: /// Returns an empty string if no array is stored. VTKM_CONT std::string GetStorageTypeName() const; + /// \brief Returns a string representation of the underlying data type. + /// + /// The returned string will be of the form `vtkm::cont::ArrayHandle` rather than the name + /// of an actual subclass. If no array is stored, an empty string is returned. + /// + VTKM_CONT std::string GetArrayTypeName() const; + /// Returns true if this array matches the ValueType template argument. /// template @@ -580,7 +587,7 @@ public: if (!this->IsType()) { VTKM_LOG_CAST_FAIL(*this, decltype(array)); - throwFailedDynamicCast(vtkm::cont::TypeToString(*this), vtkm::cont::TypeToString(array)); + throwFailedDynamicCast(this->GetArrayTypeName(), vtkm::cont::TypeToString(array)); } array = *reinterpret_cast(this->Container->ArrayHandlePointer); diff --git a/vtkm/cont/testing/UnitTestUnknownArrayHandle.cxx b/vtkm/cont/testing/UnitTestUnknownArrayHandle.cxx index bde75ad58abb0967747978a2ea431565740c0908..5afbb62953d95710e3bc0c67b3553b0af03c4388 100644 --- a/vtkm/cont/testing/UnitTestUnknownArrayHandle.cxx +++ b/vtkm/cont/testing/UnitTestUnknownArrayHandle.cxx @@ -90,8 +90,8 @@ struct CheckFunctor void operator()(const vtkm::cont::ArrayHandle& array, bool& called) const { called = true; - std::cout << " Checking for array type " << typeid(T).name() << " with storage " - << typeid(S).name() << std::endl; + std::cout << " Checking for array type " << vtkm::cont::TypeToString() << " with storage " + << vtkm::cont::TypeToString() << std::endl; CheckArray(array); } @@ -100,6 +100,8 @@ struct CheckFunctor void BasicUnknownArrayChecks(const vtkm::cont::UnknownArrayHandle& array, vtkm::IdComponent numComponents) { + std::cout << " Checking an UnknownArrayHandle containing " << array.GetArrayTypeName() + << std::endl; VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE, "Dynamic array reports unexpected size."); VTKM_TEST_ASSERT(array.GetNumberOfComponentsFlat() == numComponents, @@ -388,6 +390,10 @@ struct TryBasicVTKmType { vtkm::cont::UnknownArrayHandle array = CreateArrayUnknown(T()); + VTKM_TEST_ASSERT(array.GetValueTypeName() == vtkm::cont::TypeToString()); + VTKM_TEST_ASSERT(array.GetStorageTypeName() == + vtkm::cont::TypeToString()); + CheckUnknownArray( array, vtkm::VecTraits::NUM_COMPONENTS); @@ -405,7 +411,7 @@ void TryUnusualType() CheckUnknownArray(array, 1); VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type."); } - catch (vtkm::cont::ErrorBadValue&) + catch (vtkm::cont::ErrorBadType&) { std::cout << " Caught exception for unrecognized type." << std::endl; } diff --git a/vtkm/cont/testing/UnitTestVariantArrayHandle.cxx b/vtkm/cont/testing/UnitTestVariantArrayHandle.cxx index e5cbc52ddd9a4db8c9ac6861c229ecaf2bf92288..79467c31a7e230dd01d54b3df5c128552afd0c65 100644 --- a/vtkm/cont/testing/UnitTestVariantArrayHandle.cxx +++ b/vtkm/cont/testing/UnitTestVariantArrayHandle.cxx @@ -457,7 +457,7 @@ void TryUnusualType() CheckArrayVariant(array, 1, true); VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type."); } - catch (vtkm::cont::ErrorBadValue&) + catch (vtkm::cont::ErrorBadType&) { std::cout << " Caught exception for unrecognized type." << std::endl; }