Deprecate shareRaw (#1229)

* Deprecate shareRaw

* Load/StoreChunk documentation

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Introduce and use auxiliary::shareRaw

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Add determineDatatypeContiguous, rename determineDatatypeRaw

* Update some further instances after rebasing

* Fix docu after rebasing

* Use enable_if_t

* Add missing shared_ptr<T[]> overloads

* Throw static_assert errors for contiguous types at determineDatatype

* Fix CI errors

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: franzpoeschel

examples/3_write_serial.cpp

@@ -49,7 +49,7 @@ int main(int argc, char *argv[])
     cout << "Created a scalar mesh Record with all required openPMD "
             "attributes\n";
 
-    Datatype datatype = determineDatatype(shareRaw(global_data));
+    Datatype datatype = determineDatatype(global_data.data());
     Extent extent = {size, size};
     Dataset dataset = Dataset(datatype, extent);
     cout << "Created a Dataset of size " << dataset.extent[0] << 'x'
@@ -63,7 +63,7 @@ int main(int argc, char *argv[])
     cout << "File structure and required attributes have been written\n";
 
     Offset offset = {0, 0};
-    rho.storeChunk(shareRaw(global_data), offset, extent);
+    rho.storeChunk(global_data, offset, extent);
     cout << "Stored the whole Dataset contents as a single chunk, "
             "ready to write content\n";
 

examples/3b_write_resizable_particles.cpp

@@ -39,7 +39,7 @@ int main()
     std::vector<double> y{-2., -3., -4., -5., -6.};
 
     // both x and y the same type, otherwise we use two distinct datasets
-    Datatype dtype = determineDatatype(shareRaw(x));
+    Datatype dtype = determineDatatype(x.data());
     Extent size = {x.size()};
     auto dataset = Dataset(dtype, size, "{ \"resizable\": true }");
 

include/openPMD/Datatype.hpp

@@ -20,6 +20,8 @@
  */
 #pragma once
 
+#include "openPMD/auxiliary/TypeTraits.hpp"
+
 #include <array>
 #include <climits>
 #include <complex>
@@ -277,161 +279,62 @@ inline constexpr Datatype determineDatatype()
 template <typename T>
 inline constexpr Datatype determineDatatype(std::shared_ptr<T>)
 {
-    using DT = Datatype;
-    if (decay_equiv<T, char>::value)
-    {
-        return DT::CHAR;
-    }
-    else if (decay_equiv<T, unsigned char>::value)
-    {
-        return DT::UCHAR;
-    }
-    else if (decay_equiv<T, signed char>::value)
-    {
-        return DT::SCHAR;
-    }
-    else if (decay_equiv<T, short>::value)
-    {
-        return DT::SHORT;
-    }
-    else if (decay_equiv<T, int>::value)
-    {
-        return DT::INT;
-    }
-    else if (decay_equiv<T, long>::value)
-    {
-        return DT::LONG;
-    }
-    else if (decay_equiv<T, long long>::value)
-    {
-        return DT::LONGLONG;
-    }
-    else if (decay_equiv<T, unsigned short>::value)
-    {
-        return DT::USHORT;
-    }
-    else if (decay_equiv<T, unsigned int>::value)
-    {
-        return DT::UINT;
-    }
-    else if (decay_equiv<T, unsigned long>::value)
-    {
-        return DT::ULONG;
-    }
-    else if (decay_equiv<T, unsigned long long>::value)
-    {
-        return DT::ULONGLONG;
-    }
-    else if (decay_equiv<T, float>::value)
-    {
-        return DT::FLOAT;
-    }
-    else if (decay_equiv<T, double>::value)
-    {
-        return DT::DOUBLE;
-    }
-    else if (decay_equiv<T, long double>::value)
-    {
-        return DT::LONG_DOUBLE;
-    }
-    else if (decay_equiv<T, std::complex<float>>::value)
-    {
-        return DT::CFLOAT;
-    }
-    else if (decay_equiv<T, std::complex<double>>::value)
-    {
-        return DT::CDOUBLE;
-    }
-    else if (decay_equiv<T, std::complex<long double>>::value)
-    {
-        return DT::CLONG_DOUBLE;
-    }
-    else if (decay_equiv<T, std::string>::value)
-    {
-        return DT::STRING;
-    }
-    else if (decay_equiv<T, std::vector<char>>::value)
-    {
-        return DT::VEC_CHAR;
-    }
-    else if (decay_equiv<T, std::vector<short>>::value)
-    {
-        return DT::VEC_SHORT;
-    }
-    else if (decay_equiv<T, std::vector<int>>::value)
-    {
-        return DT::VEC_INT;
-    }
-    else if (decay_equiv<T, std::vector<long>>::value)
-    {
-        return DT::VEC_LONG;
-    }
-    else if (decay_equiv<T, std::vector<long long>>::value)
-    {
-        return DT::VEC_LONGLONG;
-    }
-    else if (decay_equiv<T, std::vector<unsigned char>>::value)
-    {
-        return DT::VEC_UCHAR;
-    }
-    else if (decay_equiv<T, std::vector<signed char>>::value)
-    {
-        return DT::VEC_SCHAR;
-    }
-    else if (decay_equiv<T, std::vector<unsigned short>>::value)
-    {
-        return DT::VEC_USHORT;
-    }
-    else if (decay_equiv<T, std::vector<unsigned int>>::value)
-    {
-        return DT::VEC_UINT;
-    }
-    else if (decay_equiv<T, std::vector<unsigned long>>::value)
-    {
-        return DT::VEC_ULONG;
-    }
-    else if (decay_equiv<T, std::vector<unsigned long long>>::value)
-    {
-        return DT::VEC_ULONGLONG;
-    }
-    else if (decay_equiv<T, std::vector<float>>::value)
-    {
-        return DT::VEC_FLOAT;
-    }
-    else if (decay_equiv<T, std::vector<double>>::value)
-    {
-        return DT::VEC_DOUBLE;
-    }
-    else if (decay_equiv<T, std::vector<long double>>::value)
-    {
-        return DT::VEC_LONG_DOUBLE;
-    }
-    else if (decay_equiv<T, std::vector<std::complex<float>>>::value)
-    {
-        return DT::VEC_CFLOAT;
-    }
-    else if (decay_equiv<T, std::vector<std::complex<double>>>::value)
-    {
-        return DT::VEC_CDOUBLE;
-    }
-    else if (decay_equiv<T, std::vector<std::complex<long double>>>::value)
-    {
-        return DT::VEC_CLONG_DOUBLE;
-    }
-    else if (decay_equiv<T, std::vector<std::string>>::value)
-    {
-        return DT::VEC_STRING;
-    }
-    else if (decay_equiv<T, std::array<double, 7>>::value)
-    {
-        return DT::ARR_DBL_7;
+    return determineDatatype<T>();
+}
+
+template <typename T>
+inline constexpr Datatype determineDatatype(T *)
+{
+    return determineDatatype<T>();
+}
+
+/*
+ * Catch-all overload for unsupported types, with static_assert errors
+ * triggered at compile-time.
+ */
+template <typename T_ContiguousContainer>
+inline constexpr Datatype determineDatatype(T_ContiguousContainer &&)
+{
+    using T_ContiguousContainer_stripped =
+        std::remove_reference_t<T_ContiguousContainer>;
+    if constexpr (auxiliary::IsContiguousContainer_v<
+                      T_ContiguousContainer_stripped>)
+    {
+        static_assert(auxiliary::dependent_false_v<T_ContiguousContainer>, R"(
+Error: Passed a contiguous container type to determineDatatype<>().
+These types are not directly supported due to colliding semantics.
+Assuming a vector object `std::vector<float> vec;`,
+use one of the following alternatives:
+
+1) If what you want is a direct openPMD::Datatype equivalent
+   of the container type, use:
+   `determineDatatype<decltype(vec)>()`
+   OR
+   `determineDatatype<std::vector<float>>()`.
+   The result will be `Datatype::VECTOR_FLOAT`.
+2) If what you want is the openPMD::Datatype equivalent of the *contained type*,
+   use the raw pointer overload by:
+   `determineDatatype(vec.data())`
+   The result will be `Datatype::FLOAT`.
+   This is the variant that you likely wish to use if intending to write data
+   from the vector via `storeChunk()`, e.g. `storeChunk(vec, {0}, {10})`.
+        )");
     }
-    else if (decay_equiv<T, bool>::value)
+    else
     {
-        return DT::BOOL;
+        static_assert(auxiliary::dependent_false_v<T_ContiguousContainer>, R"(
+Error: Unknown datatype passed to determineDatatype<>().
+For a direct translation from C++ type to the openPMD::Datatype enum, use:
+`auto determineDatatype<T>() -> Datatype`.
+
+For detecting the contained datatpye of a pointer type (shared or raw pointer),
+use either of the following overloads:
+`auto determineDatatype<T>(std::shared_ptr<T>) -> Datatype` or
+`auto determineDatatype<T>(T *) -> Datatype`.
+        )");
     }
-    else
-        return DT::UNDEFINED;
+    // Unreachable, but C++ does not know it
+    return Datatype::UNDEFINED;
 }
 
 /** Return number of bytes representing a Datatype