Stream1dNumericDataset.hpp

Go to the documentation of this file.

#ifndef RITSUKO_HDF5_STREAM_1D_NUMERIC_DATASET_HPP
#define RITSUKO_HDF5_STREAM_1D_NUMERIC_DATASET_HPP
 
#include <vector>
#include <stdexcept>
#include <cassert>
#include <limits>
#include <type_traits>
 
#include "H5Cpp.h"
#include "sanisizer/sanisizer.hpp"
 
#include "get_name.hpp"
#include "as_numeric_datatype.hpp"
 
namespace ritsuko {
 
namespace hdf5 {
 
template<typename Type_, class DataSetPointer_ = const H5::DataSet*>
class Stream1dNumericDataset {
public:
    Stream1dNumericDataset(DataSetPointer_ data_ptr, hsize_t length) : 
        my_data_ptr(std::move(data_ptr)), 
        my_full_length(length), 
        my_block_size([&]{
            assert(my_data_ptr->getSpace().getSimpleExtentNdims() == 1);
            hsize_t output;
            const auto& plist = my_data_ptr->getCreatePlist();
            if (plist.getLayout() == H5D_CHUNKED) {
                plist.getChunk(1, &output);
            } else {
                // Hard-coding the mock chunk size for contiguous datasets,
                // not worth complicating the constructor with an extra argument.
                output = sanisizer::min(length, 10000);
            }
            return output;
        }()),
        my_mspace(1, &my_block_size),
        my_fspace(1, &my_full_length)
    {
        assert([&]{
            const auto cls = my_data_ptr->getDataType().getClass();
            return cls == H5T_INTEGER || cls == H5T_FLOAT;
        }());
    }
 
public:
    hsize_t chunk_size() const {
        return my_block_size;
    }
 
    hsize_t load(Type_* buffer) {
        static_assert(std::is_arithmetic<Type_>::value);
 
        my_last_loaded += my_available;
        my_available = std::min(my_full_length - my_last_loaded, my_block_size);
        if (my_available == 0) {
            return 0;
        }
 
        constexpr hsize_t zero = 0;
        my_mspace.selectHyperslab(H5S_SELECT_SET, &my_available, &zero);
        my_fspace.selectHyperslab(H5S_SELECT_SET, &my_available, &my_last_loaded);
        my_data_ptr->read(buffer, as_numeric_datatype<Type_>(), my_mspace, my_fspace);
        return my_available;
    }
 
    hsize_t start() const {
        return my_last_loaded;
    }
 
private:
    DataSetPointer_ my_data_ptr;
    hsize_t my_full_length, my_block_size;
    H5::DataSpace my_mspace;
    H5::DataSpace my_fspace;
    hsize_t my_last_loaded = 0;
    hsize_t my_available = 0;
 
    static_assert(std::is_base_of<H5::DataSet, I<decltype(*my_data_ptr)> >::value);
};
 
}
 
}
 
#endif