morphio 3.3.5__tar.gz → 3.3.6__tar.gz

{MorphIO-3.3.5 → MorphIO-3.3.6}/.github/workflows/coverage_test.yaml

@@ -28,4 +28,4 @@ jobs:
         uses: coverallsapp/github-action@master
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
-          path-to-lcov: build/build-coverage/coverage.info.cleaned
+          path-to-lcov: build/build-coverage/coverage.info

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/CMake/HighFiveConfig.cmake.in

@@ -15,8 +15,6 @@ if(TARGET HighFive)
     return()
 endif()
 
-@PACKAGE_INIT@
-
 # Get HighFive targets
 include("${CMAKE_CURRENT_LIST_DIR}/HighFiveTargets.cmake")
 
@@ -63,12 +61,8 @@ if(HIGHFIVE_USE_XTENSOR AND NOT CMAKE_VERSION VERSION_LESS 3.8)
   set_property(TARGET HighFive APPEND PROPERTY INTERFACE_COMPILE_FEATURES cxx_std_14)
 endif()
 
-if(NOT HighFive_FIND_QUIETLY)
-  message(STATUS "HIGHFIVE @PROJECT_VERSION@: (Re)Detecting Highfive dependencies (HIGHFIVE_USE_INSTALL_DEPS=NO)")
-endif()
+message(STATUS "HIGHFIVE @PROJECT_VERSION@: (Re)Detecting Highfive dependencies (HIGHFIVE_USE_INSTALL_DEPS=NO)")
 include("${CMAKE_CURRENT_LIST_DIR}/HighFiveTargetDeps.cmake")
 foreach(dependency HighFive_libheaders libdeps)
     copy_interface_properties(HighFive ${dependency})
 endforeach()
-
-check_required_components(HighFive)

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/CMake/config/CompilerFlagsHelpers.cmake

@@ -35,7 +35,9 @@ foreach(COMPILER_LANGUAGE ${SUPPORTED_COMPILER_LANGUAGE_LIST})
         OR CMAKE_${COMPILER_LANGUAGE}_COMPILER_ID MATCHES "GNU"
         OR CMAKE_${COMPILER_LANGUAGE}_COMPILER_ID MATCHES "Intel")
 		set(CMAKE_${COMPILER_LANGUAGE}_WARNING_ALL " -Wall -Wextra")
-		string(CONCAT CMAKE_${COMPILER_LANGUAGE}_WARNING_DEBUG " -Werror -Wshadow -Wnon-virtual-dtor -Wunused -Woverloaded-virtual -Wformat=2 -Wconversion -Wsign-conversion -Wno-error=deprecated-declarations"
+		string(CONCAT CMAKE_${COMPILER_LANGUAGE}_WARNING_DEBUG
+			" -Werror -Wshadow -Wnon-virtual-dtor -Wunused -Woverloaded-virtual"
+			" -Wformat=2 -Wconversion -Wsign-conversion -Wno-error=deprecated-declarations"
 		)
 		if(NOT CMAKE_${COMPILER_LANGUAGE}_COMPILER_IS_ICC)
 			string(CONCAT CMAKE_${COMPILER_LANGUAGE}_WARNING_DEBUG

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/CMakeLists.txt

@@ -113,7 +113,7 @@ install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/
 
 # Disable test if Boost was expressly disabled, or if HighFive is a sub-project
 if (NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-  if(HIGHFIVE_UNIT_TESTS AND NOT HighFive_FIND_QUIETLY)
+  if(HIGHFIVE_UNIT_TESTS)
     message(WARNING "Unit tests have been DISABLED.")
   endif()
   set(HIGHFIVE_UNIT_TESTS FALSE)

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/doc/Doxyfile

@@ -865,7 +865,6 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/../include \
-                         @CMAKE_CURRENT_SOURCE_DIR@/installation.md \
                          @CMAKE_CURRENT_SOURCE_DIR@/../CHANGELOG.md \
                          @CMAKE_CURRENT_SOURCE_DIR@/../README.md
 

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/include/highfive/H5Attribute.hpp

@@ -87,17 +87,9 @@ class Attribute: public Object, public PathTraits<Attribute> {
     template <typename T>
     void read(T& array) const;
 
-    /// \brief Read the attribute into a buffer.
-    ///
-    /// Note, this is the shallowest wrapper around `H5Aread`.
-    template <typename T>
-    void read(T* array, const DataType& mem_datatype) const;
-
     /// \brief Read the attribute into a buffer
-    ///
-    /// This overload deduces the memory datatype from `T`.
     template <typename T>
-    void read(T* array) const;
+    void read(T* array, const DataType& dtype = {}) const;
 
     ///
     /// Write the integrality N-dimension buffer to this attribute
@@ -109,19 +101,9 @@ class Attribute: public Object, public PathTraits<Attribute> {
     template <typename T>
     void write(const T& buffer);
 
-    /// \brief Write to this attribute from `buffer`.
-    ///
-    /// Note that this is the shallowest wrapper around `H5Awrite`. It's useful
-    /// if you need full control. If possible prefer `Attribute::write`.
-    template <typename T>
-    void write_raw(const T* buffer, const DataType& mem_dtype);
-
-    /// \brief Write to this attribute from `buffer`.
-    ///
-    /// This version attempts to automatically deduce the datatype
-    /// of the buffer. Note, that the file datatype is already set.
+    /// \brief Write a buffer to this attribute
     template <typename T>
-    void write_raw(const T* buffer);
+    void write_raw(const T* buffer, const DataType& dtype = {});
 
     /// \brief Get the list of properties for creation of this attribute
     AttributeCreateProps getCreatePropertyList() const {

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/include/highfive/bits/H5Attribute_misc.hpp

@@ -100,23 +100,19 @@ inline void Attribute::read(T& array) const {
 }
 
 template <typename T>
-inline void Attribute::read(T* array, const DataType& mem_datatype) const {
+inline void Attribute::read(T* array, const DataType& dtype) const {
     static_assert(!std::is_const<T>::value,
                   "read() requires a non-const structure to read data into");
+    using element_type = typename details::inspector<T>::base_type;
+    // Auto-detect mem datatype if not provided
+    const DataType& mem_datatype = dtype.empty() ? create_and_check_datatype<element_type>()
+                                                 : dtype;
 
     if (H5Aread(getId(), mem_datatype.getId(), static_cast<void*>(array)) < 0) {
         HDF5ErrMapper::ToException<AttributeException>("Error during HDF5 Read: ");
     }
 }
 
-template <typename T>
-inline void Attribute::read(T* array) const {
-    using element_type = typename details::inspector<T>::base_type;
-    const DataType& mem_datatype = create_and_check_datatype<element_type>();
-
-    read(array, mem_datatype);
-}
-
 template <typename T>
 inline void Attribute::write(const T& buffer) {
     const DataSpace& mem_space = getMemSpace();
@@ -141,18 +137,13 @@ inline void Attribute::write(const T& buffer) {
 }
 
 template <typename T>
-inline void Attribute::write_raw(const T* buffer, const DataType& mem_datatype) {
+inline void Attribute::write_raw(const T* buffer, const DataType& dtype) {
+    using element_type = typename details::inspector<T>::base_type;
+    const auto& mem_datatype = dtype.empty() ? create_and_check_datatype<element_type>() : dtype;
+
     if (H5Awrite(getId(), mem_datatype.getId(), buffer) < 0) {
         HDF5ErrMapper::ToException<DataSetException>("Error during HDF5 Write: ");
     }
 }
 
-template <typename T>
-inline void Attribute::write_raw(const T* buffer) {
-    using element_type = typename details::inspector<T>::base_type;
-    const auto& mem_datatype = create_and_check_datatype<element_type>();
-
-    write_raw(buffer, mem_datatype);
-}
-
 }  // namespace HighFive

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/include/highfive/bits/H5DataType_misc.hpp

@@ -26,64 +26,6 @@
 
 namespace HighFive {
 
-namespace detail {
-
-inline hid_t h5t_copy(hid_t original) {
-    auto copy = H5Tcopy(original);
-    if (copy == H5I_INVALID_HID) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error copying datatype.");
-    }
-
-    return copy;
-}
-
-inline hsize_t h5t_get_size(hid_t hid) {
-    hsize_t size = H5Tget_size(hid);
-    if (size == 0) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error getting size of datatype.");
-    }
-
-    return size;
-}
-
-inline H5T_cset_t h5t_get_cset(hid_t hid) {
-    auto cset = H5Tget_cset(hid);
-    if (cset == H5T_CSET_ERROR) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error getting cset of datatype.");
-    }
-
-    return cset;
-}
-
-inline H5T_str_t h5t_get_strpad(hid_t hid) {
-    auto strpad = H5Tget_strpad(hid);
-    if (strpad == H5T_STR_ERROR) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error getting strpad of datatype.");
-    }
-
-    return strpad;
-}
-
-inline void h5t_set_size(hid_t hid, hsize_t size) {
-    if (H5Tset_size(hid, size) < 0) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error setting size of datatype.");
-    }
-}
-
-inline void h5t_set_cset(hid_t hid, H5T_cset_t cset) {
-    if (H5Tset_cset(hid, cset) < 0) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error setting cset of datatype.");
-    }
-}
-
-inline void h5t_set_strpad(hid_t hid, H5T_str_t strpad) {
-    if (H5Tset_strpad(hid, strpad) < 0) {
-        HDF5ErrMapper::ToException<DataTypeException>("Error setting strpad of datatype.");
-    }
-}
-}  // namespace detail
-
-
 namespace {  // unnamed
 inline DataTypeClass convert_type_class(const H5T_class_t& tclass);
 inline std::string type_class_string(DataTypeClass);
@@ -99,7 +41,7 @@ inline DataTypeClass DataType::getClass() const {
 }
 
 inline size_t DataType::getSize() const {
-    return detail::h5t_get_size(_hid);
+    return H5Tget_size(_hid);
 }
 
 inline bool DataType::operator==(const DataType& other) const {
@@ -133,61 +75,61 @@ inline std::string DataType::string() const {
 // char mapping
 template <>
 inline AtomicType<char>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_CHAR);
+    _hid = H5Tcopy(H5T_NATIVE_CHAR);
 }
 
 template <>
 inline AtomicType<signed char>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_SCHAR);
+    _hid = H5Tcopy(H5T_NATIVE_SCHAR);
 }
 
 template <>
 inline AtomicType<unsigned char>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_UCHAR);
+    _hid = H5Tcopy(H5T_NATIVE_UCHAR);
 }
 
 // short mapping
 template <>
 inline AtomicType<short>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_SHORT);
+    _hid = H5Tcopy(H5T_NATIVE_SHORT);
 }
 
 template <>
 inline AtomicType<unsigned short>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_USHORT);
+    _hid = H5Tcopy(H5T_NATIVE_USHORT);
 }
 
 // integer mapping
 template <>
 inline AtomicType<int>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_INT);
+    _hid = H5Tcopy(H5T_NATIVE_INT);
 }
 
 template <>
 inline AtomicType<unsigned>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_UINT);
+    _hid = H5Tcopy(H5T_NATIVE_UINT);
 }
 
 // long mapping
 template <>
 inline AtomicType<long>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_LONG);
+    _hid = H5Tcopy(H5T_NATIVE_LONG);
 }
 
 template <>
 inline AtomicType<unsigned long>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_ULONG);
+    _hid = H5Tcopy(H5T_NATIVE_ULONG);
 }
 
 // long long mapping
 template <>
 inline AtomicType<long long>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_LLONG);
+    _hid = H5Tcopy(H5T_NATIVE_LLONG);
 }
 
 template <>
 inline AtomicType<unsigned long long>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_ULLONG);
+    _hid = H5Tcopy(H5T_NATIVE_ULLONG);
 }
 
 // half-float, float, double and long double mapping
@@ -196,11 +138,11 @@ using float16_t = half_float::half;
 
 template <>
 inline AtomicType<float16_t>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_FLOAT);
+    _hid = H5Tcopy(H5T_NATIVE_FLOAT);
     // Sign position, exponent position, exponent size, mantissa position, mantissa size
     H5Tset_fields(_hid, 15, 10, 5, 0, 10);
     // Total datatype size (in bytes)
-    detail::h5t_set_size(_hid, 2);
+    H5Tset_size(_hid, 2);
     // Floating point exponent bias
     H5Tset_ebias(_hid, 15);
 }
@@ -208,17 +150,17 @@ inline AtomicType<float16_t>::AtomicType() {
 
 template <>
 inline AtomicType<float>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_FLOAT);
+    _hid = H5Tcopy(H5T_NATIVE_FLOAT);
 }
 
 template <>
 inline AtomicType<double>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_DOUBLE);
+    _hid = H5Tcopy(H5T_NATIVE_DOUBLE);
 }
 
 template <>
 inline AtomicType<long double>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_LDOUBLE);
+    _hid = H5Tcopy(H5T_NATIVE_LDOUBLE);
 }
 
 // std string
@@ -231,7 +173,7 @@ inline AtomicType<std::string>::AtomicType() {
 // std byte
 template <>
 inline AtomicType<std::byte>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_NATIVE_B8);
+    _hid = H5Tcopy(H5T_NATIVE_B8);
 }
 #endif
 
@@ -329,7 +271,7 @@ inline std::string FixedLenStringArray<N>::getString(std::size_t i) const {
 // Reference mapping
 template <>
 inline AtomicType<Reference>::AtomicType() {
-    _hid = detail::h5t_copy(H5T_STD_REF_OBJ);
+    _hid = H5Tcopy(H5T_STD_REF_OBJ);
 }
 
 inline size_t find_first_atomic_member_size(hid_t hid) {
@@ -352,7 +294,7 @@ inline size_t find_first_atomic_member_size(hid_t hid) {
     } else if (H5Tget_class(hid) == H5T_STRING) {
         return 1;
     }
-    return detail::h5t_get_size(hid);
+    return H5Tget_size(hid);
 }
 
 // Calculate the padding required to align an element of a struct
@@ -383,7 +325,7 @@ inline void CompoundType::create(size_t size) {
 
         // Do a first pass to find the total size of the compound datatype
         for (auto& member: members) {
-            size_t member_size = detail::h5t_get_size(member.base_type.getId());
+            size_t member_size = H5Tget_size(member.base_type.getId());
 
             if (member_size == 0) {
                 throw DataTypeException("Cannot get size of DataType with hid: " +
@@ -451,9 +393,12 @@ inline void EnumType<T>::commit(const Object& object, const std::string& name) c
 namespace {
 
 inline hid_t create_string(size_t length) {
-    hid_t _hid = detail::h5t_copy(H5T_C_S1);
-    detail::h5t_set_size(_hid, length);
-    detail::h5t_set_cset(_hid, H5T_CSET_UTF8);
+    hid_t _hid = H5Tcopy(H5T_C_S1);
+    if (H5Tset_size(_hid, length) < 0) {
+        HDF5ErrMapper::ToException<DataTypeException>("Unable to define datatype size to variable");
+    }
+    // define encoding to UTF-8 by default
+    H5Tset_cset(_hid, H5T_CSET_UTF8);
     return _hid;
 }
 

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/include/highfive/bits/H5Path_traits_misc.hpp

@@ -34,7 +34,7 @@ inline PathTraits<Derivate>::PathTraits() {
 template <typename Derivate>
 inline std::string PathTraits<Derivate>::getPath() const {
     return details::get_name([this](char* buffer, size_t length) {
-        return H5Iget_name(static_cast<const Derivate&>(*this).getId(), buffer, length);
+        return H5Iget_name(static_cast<const Derivate*>(this)->getId(), buffer, length);
     });
 }
 

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/include/highfive/bits/H5Slice_traits.hpp

@@ -258,15 +258,6 @@ class SliceTraits {
     /// Therefore, the only memspaces supported for general hyperslabs are one-dimensional arrays.
     Selection select(const HyperSlab& hyperslab) const;
 
-    ///
-    /// \brief Select an \p hyperslab in the current Slice/Dataset.
-    ///
-    /// If the selection can be read into a simple, multi-dimensional dataspace,
-    /// then this overload enable specifying the shape of the memory dataspace
-    /// with `memspace`. Note, that simple implies no offsets, strides or
-    /// number of blocks, just the size of the block in each dimension.
-    Selection select(const HyperSlab& hyperslab, const DataSpace& memspace) const;
-
     ///
     /// \brief Select a region in the current Slice/Dataset of \p count points at
     /// \p offset separated by \p stride. If strides are not provided they will
@@ -317,21 +308,9 @@ class SliceTraits {
     /// \param xfer_props: Data Transfer properties
     template <typename T>
     void read(T* array,
-              const DataType& dtype,
+              const DataType& dtype = DataType(),
               const DataTransferProps& xfer_props = DataTransferProps()) const;
 
-    ///
-    /// Read the entire dataset into a raw buffer
-    ///
-    /// Same as `read(T*, const DataType&, const DataTransferProps&)`. However,
-    /// this overload deduces the HDF5 datatype of the element of `array` from
-    /// `T`. Note, that the file datatype is already fixed.
-    ///
-    /// \param array: A buffer containing enough space for the data
-    /// \param xfer_props: Data Transfer properties
-    template <typename T>
-    void read(T* array, const DataTransferProps& xfer_props = DataTransferProps()) const;
-
     ///
     /// Write the integrality N-dimension buffer to this dataset
     /// An exception is raised is if the numbers of dimension of the buffer and
@@ -343,33 +322,22 @@ class SliceTraits {
     void write(const T& buffer, const DataTransferProps& xfer_props = DataTransferProps());
 
     ///
-    /// Write from a raw pointer into this dataset.
+    /// Write from a raw buffer into this dataset
     ///
     /// No dimensionality checks will be performed, it is the user's
     /// responsibility to ensure that the buffer holds the right amount of
     /// elements. For n-dimensional matrices the buffer layout follows H5
     /// default conventions.
-    ///
-    /// Note, this is the shallowest wrapper around `H5Dwrite` and should
-    /// be used if full control is needed. Generally prefer `write`.
-    ///
     /// \param buffer: A buffer containing the data to be written
-    /// \param dtype: The datatype of `buffer`, i.e. the memory data type.
+    /// \param dtype: The type of the data, in case it cannot be automatically guessed
     /// \param xfer_props: The HDF5 data transfer properties, e.g. collective MPI-IO.
     template <typename T>
     void write_raw(const T* buffer,
-                   const DataType& mem_datatype,
+                   const DataType& dtype = DataType(),
                    const DataTransferProps& xfer_props = DataTransferProps());
 
-    ///
-    /// Write from a raw pointer into this dataset.
-    ///
-    /// Same as `write_raw(const T*, const DataTransferProps&)`. However, this
-    /// overload attempts to guess the data type of `buffer`, i.e. the memory
-    /// datatype. Note that the file datatype is already fixed.
-    ///
-    template <typename T>
-    void write_raw(const T* buffer, const DataTransferProps& xfer_props = DataTransferProps());
+  protected:
+    inline Selection select_impl(const HyperSlab& hyperslab, const DataSpace& memspace) const;
 };
 
 }  // namespace HighFive

{MorphIO-3.3.5 → MorphIO-3.3.6}/3rdparty/HighFive/include/highfive/bits/H5Slice_traits_misc.hpp

@@ -64,8 +64,8 @@ inline ElementSet::ElementSet(const std::vector<std::vector<std::size_t>>& eleme
 }
 
 template <typename Derivate>
-inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyperslab,
-                                               const DataSpace& memspace) const {
+inline Selection SliceTraits<Derivate>::select_impl(const HyperSlab& hyperslab,
+                                                    const DataSpace& memspace) const {
     // Note: The current limitation are that memspace must describe a
     //       packed memspace.
     //
@@ -98,7 +98,7 @@ inline Selection SliceTraits<Derivate>::select(const std::vector<size_t>& offset
                                                const std::vector<size_t>& block) const {
     auto slab = HyperSlab(RegularHyperSlab(offset, count, stride, block));
     auto memspace = DataSpace(count);
-    return select(slab, memspace);
+    return select_impl(slab, memspace);
 }
 
 template <typename Derivate>
@@ -121,7 +121,7 @@ inline Selection SliceTraits<Derivate>::select(const std::vector<size_t>& column
     std::vector<size_t> memdims = dims;
     memdims.back() = columns.size();
 
-    return select(slab, DataSpace(memdims));
+    return select_impl(slab, DataSpace(memdims));
 }
 
 template <typename Derivate>
@@ -214,12 +214,16 @@ inline void SliceTraits<Derivate>::read(T& array, const DataTransferProps& xfer_
 template <typename Derivate>
 template <typename T>
 inline void SliceTraits<Derivate>::read(T* array,
-                                        const DataType& mem_datatype,
+                                        const DataType& dtype,
                                         const DataTransferProps& xfer_props) const {
     static_assert(!std::is_const<T>::value,
                   "read() requires a non-const structure to read data into");
-
     const auto& slice = static_cast<const Derivate&>(*this);
+    using element_type = typename details::inspector<T>::base_type;
+
+    // Auto-detect mem datatype if not provided
+    const DataType& mem_datatype = dtype.empty() ? create_and_check_datatype<element_type>()
+                                                 : dtype;
 
     if (H5Dread(details::get_dataset(slice).getId(),
                 mem_datatype.getId(),
@@ -231,15 +235,6 @@ inline void SliceTraits<Derivate>::read(T* array,
     }
 }
 
-template <typename Derivate>
-template <typename T>
-inline void SliceTraits<Derivate>::read(T* array, const DataTransferProps& xfer_props) const {
-    using element_type = typename details::inspector<T>::base_type;
-    const DataType& mem_datatype = create_and_check_datatype<element_type>();
-
-    read(array, mem_datatype, xfer_props);
-}
-
 
 template <typename Derivate>
 template <typename T>
@@ -271,9 +266,11 @@ inline void SliceTraits<Derivate>::write(const T& buffer, const DataTransferProp
 template <typename Derivate>
 template <typename T>
 inline void SliceTraits<Derivate>::write_raw(const T* buffer,
-                                             const DataType& mem_datatype,
+                                             const DataType& dtype,
                                              const DataTransferProps& xfer_props) {
+    using element_type = typename details::inspector<T>::base_type;
     const auto& slice = static_cast<const Derivate&>(*this);
+    const auto& mem_datatype = dtype.empty() ? create_and_check_datatype<element_type>() : dtype;
 
     if (H5Dwrite(details::get_dataset(slice).getId(),
                  mem_datatype.getId(),
@@ -285,14 +282,5 @@ inline void SliceTraits<Derivate>::write_raw(const T* buffer,
     }
 }
 
-template <typename Derivate>
-template <typename T>
-inline void SliceTraits<Derivate>::write_raw(const T* buffer, const DataTransferProps& xfer_props) {
-    using element_type = typename details::inspector<T>::base_type;
-    const auto& mem_datatype = create_and_check_datatype<element_type>();
-
-    write_raw(buffer, mem_datatype, xfer_props);
-}
-
 
 }  // namespace HighFive

{MorphIO-3.3.5 → MorphIO-3.3.6}/CHANGELOG.md

@@ -1,3 +1,19 @@
+v3.3.6
+======
+Improvements:
+* don't allow negative IDs in SWC, except for the special parent == -1, for the first sample (#466)
+* Bump HighFive to v2.7.1 (#449)
+* Increase allowed section type to 19 (#462)
+* Have warnings for incompatible soma-types (#458):
+    * SWC files should have soma that are either a point, or a set of stacked cylinders.
+    * H5 & ASC consider the soma to be a contour
+    * allow assignment of soma type for mutable soma
+    * add errors for soma access / write if wrong size
+     - ERROR_SOMA_INVALID_SINGLE_POINT
+     - ERROR_SOMA_INVALID_THREE_POINT_CYLINDER
+     - ERROR_SOMA_INVALID_CONTOUR
+* increased test coverage and cleanup
+
 v3.3.5
 ======
 New Features: