include/highfive/boost_ublas.hpp

0001 #pragma once
0002
0003 #include "bits/H5Inspector_decl.hpp"
0004 #include "H5Exception.hpp"
0005
0006 #include <boost/numeric/ublas/matrix.hpp>
0007
0008 namespace HighFive {
0009 namespace details {
0010
0011 template <typename T>
0012 struct inspector<boost::numeric::ublas::matrix<T>> {
0013     using type = boost::numeric::ublas::matrix<T>;
0014     using value_type = unqualified_t<T>;
0015     using base_type = typename inspector<value_type>::base_type;
0016     using hdf5_type = typename inspector<value_type>::hdf5_type;
0017
0018     static constexpr size_t ndim = 2;
0019     static constexpr size_t min_ndim = ndim + inspector<value_type>::min_ndim;
0020     static constexpr size_t max_ndim = ndim + inspector<value_type>::max_ndim;
0021
0022     static constexpr bool is_trivially_copyable = std::is_trivially_copyable<value_type>::value &&
0023                                                   inspector<value_type>::is_trivially_copyable;
0024     static constexpr bool is_trivially_nestable = false;
0025
0026     static size_t getRank(const type& val) {
0027         return ndim + inspector<value_type>::getRank(val(0, 0));
0028     }
0029
0030     static std::vector<size_t> getDimensions(const type& val) {
0031         std::vector<size_t> sizes{val.size1(), val.size2()};
0032         auto s = inspector<value_type>::getDimensions(val(0, 0));
0033         sizes.insert(sizes.end(), s.begin(), s.end());
0034         return sizes;
0035     }
0036
0037     static void prepare(type& val, const std::vector<size_t>& dims) {
0038         if (dims.size() < ndim) {
0039             std::ostringstream os;
0040             os << "Impossible to pair DataSet with " << dims.size() << " dimensions into a " << ndim
0041                << " boost::numeric::ublas::matrix";
0042             throw DataSpaceException(os.str());
0043         }
0044         val.resize(dims[0], dims[1], false);
0045     }
0046
0047     static hdf5_type* data(type& val) {
0048         return inspector<value_type>::data(val(0, 0));
0049     }
0050
0051     static const hdf5_type* data(const type& val) {
0052         return inspector<value_type>::data(val(0, 0));
0053     }
0054
0055     static void serialize(const type& val, const std::vector<size_t>& dims, hdf5_type* m) {
0056         size_t size = val.size1() * val.size2();
0057         auto subdims = std::vector<size_t>(dims.begin() + ndim, dims.end());
0058         size_t subsize = compute_total_size(subdims);
0059         for (size_t i = 0; i < size; ++i) {
0060             inspector<value_type>::serialize(*(&val(0, 0) + i), subdims, m + i * subsize);
0061         }
0062     }
0063
0064     static void unserialize(const hdf5_type* vec_align,
0065                             const std::vector<size_t>& dims,
0066                             type& val) {
0067         std::vector<size_t> next_dims(dims.begin() + ndim, dims.end());
0068         size_t subsize = compute_total_size(next_dims);
0069         size_t size = val.size1() * val.size2();
0070         for (size_t i = 0; i < size; ++i) {
0071             inspector<value_type>::unserialize(vec_align + i * subsize,
0072                                                next_dims,
0073                                                *(&val(0, 0) + i));
0074         }
0075     }
0076 };
0077
0078 }  // namespace details
0079 }  // namespace HighFive