Add inspector::is_trivially_nestable.

[1uc]

We need this because std::span is considered std::is_trivially_copyable.

[PhilipDeegan]

we're seeing an error now like RuntimeError: Not possible to serialize a T* I'm guessing because of this...

testing locally without this commit to be sure

edit: no error confirmed after popping current top two commits (including this one)

[1uc]

Thanks for letting us know. I've checked the PR again, and nothing sticks out as wrong. Do you know what T is and if T* is inside some other container, the type of that container?

[PhilipDeegan]

T is a double in this context, but we do some pointer casting to force a 1d vector data pointer into a 2 or 3d dataset

which is feasibly not how it should be done, but it's what has worked until now

template<std::size_t dim, typename Data>
NO_DISCARD auto pointer_dim_caster(Data* data)
{
    if constexpr (dim == 1)
        return data;
    if constexpr (dim == 2)
        return reinterpret_cast<Data const** const>(data);
    if constexpr (dim == 3)
        return reinterpret_cast<Data const*** const>(data);
}

[1uc]

Yes! That was an interesting surprise. We still have a test for a variation using write_raw here:

HighFive/tests/unit/test_legacy.cpp

Lines 27 to 29 in 070badf

	std::vector<datatype> const t1(DIMS[0] * DIMS[1] * DIMS[2], 1);
	auto raw_3d_vec_const = reinterpret_cast<datatype const* const* const*>(t1.data());
	dataset.write_raw(raw_3d_vec_const);

I see three options:

• Use write_raw without (or with) the magic in pointer_dim_caster.
• Use the almost ready reshapeMemSpace, see Implement squeeze and reshape. #991. Comments are welcome.
• Use mdspan which should be one of the next things I'd like to implement.

[PhilipDeegan]

what we're doing is essentially the same as the legacy test, which I'm surprised if it's passing

I can test write_raw without the reinterpret_cast, as the shape given is the correct dimension
we have no plans for C++23 right now

[PhilipDeegan]

without the reinterpret_cast I get

[PhilipDeegan]

oh I wasn't using write_raw, testing...

[1uc]

The write_raw doesn't care about dimensions and such, it's just a very shallow wrapper:

HighFive/include/highfive/bits/H5Slice_traits_misc.hpp

Lines 268 to 279 in 070badf

	inline void SliceTraits<Derivate>::write_raw(const T* buffer,
	const DataType& mem_datatype,
	const DataTransferProps& xfer_props) {
	const auto& slice = static_cast<const Derivate&>(*this);
	detail::h5d_write(details::get_dataset(slice).getId(),
	mem_datatype.getId(),
	details::get_memspace_id(slice),
	slice.getSpace().getId(),
	xfer_props.getId(),
	static_cast<const void*>(buffer));
	}

The type of the pointer doesn't matter, they're all converted to void * and sent to HDF5.

[PhilipDeegan]

it seems ok with write_raw and no reintrepret_cast 👍

[1uc]

Glad to hear that!

[1uc]

This change will be documented in the Migration Guide via #996.

Migration Guide: https://bluebrain.github.io/HighFive/md__2home_2runner_2work_2_high_five_2_high_five_2doc_2migration__guide.html