7template <
typename Derivate, 
typename T>
 
   12template <
typename Derivate, 
typename T>
 
   17template <
typename Derivate, 
typename T>
 
   19  static_assert(!std::is_const<T>::value,
 
   20      "read() requires a non-const structure to read data into");
 
   21  const auto& slice = 
static_cast<const Derivate&
>(self);
 
   24  v.resize(slice.getSpace().getElementCount());
 
   26  slice.read(v.data(), slice.getDataType());
 
   30template <
typename Derivate, 
typename T>
 
   32  static_assert(!std::is_const<T>::value,
 
   33      "read() requires a non-const structure to read data into");
 
   34  const auto& slice = 
static_cast<const Derivate&
>(self);
 
   36  std::vector<size_t> dims = slice.getSpace().getDimensions();
 
   39  if (dims.size() == 1){
 
   41  } 
else if (dims.size() == 2){
 
   42    M.resize(dims[1], dims[0]);
 
   44    M.resize(slice.getSpace().getElementCount(), 1);
 
   47  slice.read(M.data(), slice.getDataType());
 
   55void ElementSet_py(py::class_<ElementSet> &py_obj);
 
   57template <
typename Derivate>
 
   60      .def(
"select", py::overload_cast<
 
   61           const std::vector<size_t>&,
 
   62           const std::vector<size_t>&,
 
   63           const std::vector<size_t>&,
 
   64           const std::vector<size_t>&>(
 
   68           py::arg_v(
"stride", std::vector<size_t>(), 
"list()"),
 
   69           py::arg_v(
"block", std::vector<size_t>(), 
"list()"))
 
   70      .def(
"select", py::overload_cast<
 
   74      .def(
"select_rows", py::overload_cast<
 
   75           const std::vector<size_t>&, 
size_t, 
size_t>(
 
   78           py::arg_v(
"offset", 0, 
"0"),
 
   79           py::arg_v(
"count", 0, 
"0"))
 
   80      .def(
"select_cols", py::overload_cast<
 
   81           const std::vector<size_t>&, 
size_t, 
size_t>(
 
   84           py::arg_v(
"offset", 0, 
"0"),
 
   85           py::arg_v(
"count", 0, 
"0"))
 
   90           py::arg(
"data"), 
"An exception is raised if the numbers of dimension of the buffer and of the dataset are different")
 
  122      .def(
"write_raw", &ext::write_vector_raw<Derivate, long long>,
 
  124           "No dimensionality checks will be performed")
 
  125      .def(
"write_raw", &ext::write_vector_raw<Derivate, double>,
 
  127      .def(
"write_raw", &ext::write_vector_raw<Derivate, std::complex<double>>,
 
  133      .def(
"write_raw", &ext::write_eigen_raw<Derivate, bool>,
 
  135      .def(
"write_raw", &ext::write_eigen_raw<Derivate, char>,
 
  137      .def(
"write_raw", &ext::write_eigen_raw<Derivate, signed char>,
 
  139      .def(
"write_raw", &ext::write_eigen_raw<Derivate, unsigned char>,
 
  141      .def(
"write_raw", &ext::write_eigen_raw<Derivate, short>,
 
  143      .def(
"write_raw", &ext::write_eigen_raw<Derivate, unsigned short>,
 
  145      .def(
"write_raw", &ext::write_eigen_raw<Derivate, int>,
 
  147      .def(
"write_raw", &ext::write_eigen_raw<Derivate, unsigned>,
 
  149      .def(
"write_raw", &ext::write_eigen_raw<Derivate, long long>,
 
  151      .def(
"write_raw", &ext::write_eigen_raw<Derivate, unsigned long long>,
 
  153      .def(
"write_raw", &ext::write_eigen_raw<Derivate, float>,
 
  155      .def(
"write_raw", &ext::write_eigen_raw<Derivate, double>,
 
  157      .def(
"write_raw", &ext::write_eigen_raw<Derivate, std::complex<float>>,
 
  159      .def(
"write_raw", &ext::write_eigen_raw<Derivate, std::complex<double>>,
 
  164      .def(
"readBool", &ext::read_eigen_raw<Derivate, bool>)
 
  165      .def(
"readChar", &ext::read_eigen_raw<Derivate, char>)
 
  166      .def(
"readSChar", &ext::read_eigen_raw<Derivate, signed char>)
 
  167      .def(
"readUChar", &ext::read_eigen_raw<Derivate, unsigned char>)
 
  168      .def(
"readShort", &ext::read_eigen_raw<Derivate, short>)
 
  169      .def(
"readUShort", &ext::read_eigen_raw<Derivate, unsigned short>)
 
  170      .def(
"readInt", &ext::read_eigen_raw<Derivate, int>)
 
  171      .def(
"readUInt", &ext::read_eigen_raw<Derivate, unsigned>)
 
  172      .def(
"readLong", &ext::read_eigen_raw<Derivate, long>)
 
  173      .def(
"readULong", &ext::read_eigen_raw<Derivate, unsigned long>)
 
  174      .def(
"readLLong", &ext::read_eigen_raw<Derivate, long long>)
 
  175      .def(
"readULLong", &ext::read_eigen_raw<Derivate, unsigned long long>)
 
  176      .def(
"readFloat", &ext::read_eigen_raw<Derivate, float>)
 
  177      .def(
"readDouble", &ext::read_eigen_raw<Derivate, double>)
 
  178      .def(
"readCFloat", &ext::read_eigen_raw<Derivate, std::complex<float>>)
 
  179      .def(
"readCDouble", &ext::read_eigen_raw<Derivate, std::complex<double>>)
 
  180      .def(
"readStr", &ext::read_vector_raw<Derivate, const char*>);
 
create an HDF5 DataType from a C++ type
Definition H5DataType.hpp:124
Definition H5Slice_traits.hpp:20
Definition H5Slice_traits.hpp:54
void write_raw(const T *buffer, const DataType &dtype=DataType())
Definition H5Slice_traits_misc.hpp:293