validate.hpp

Go to the documentation of this file.

#ifndef RITSUKO_CVLS_VALIDATE_HPP
#define RITSUKO_CVLS_VALIDATE_HPP
 
#include <string>
#include <vector>
#include <stdexcept>
#include <limits>
#include <cassert>
#include <algorithm>
 
#include "H5Cpp.h"
#include "sanisizer/sanisizer.hpp"
 
#include "../hdf5/IterateChunks.hpp"
#include "../hdf5/mock_contiguous_chunks.hpp"
#include "../itoa.hpp"
#include "Pointer.hpp"
 
namespace ritsuko {
 
namespace cvls {
 
template<typename Offset_, typename Length_>
inline void validate_scalar_pointer(const H5::DataSet& data, hsize_t heap_length) {
    try {
        validate_pointer_datatype(data, std::numeric_limits<Offset_>::digits, std::numeric_limits<Length_>::digits);
    } catch (std::exception& e) {
        throw std::runtime_error("failed to validate the datatype; " + std::string(e.what()));
    }
 
    assert(data.getSpace().getSimpleExtentNdims() == 0);
 
    auto dtype = define_pointer_datatype<Offset_, Length_>();
    Pointer<Offset_, Length_> val;
    data.read(&val, dtype);
 
    if (is_Pointer_out_of_range(val, heap_length)) {
        throw std::runtime_error("pointer is out of range of the heap");
    }
}
 
struct Validate1dPointersOptions {
    hsize_t contiguous_chunk_size = sanisizer::cap<hsize_t>(10000);
};
 
template<typename Offset_, typename Length_>
inline void validate_1d_pointers(const H5::DataSet& data, hsize_t full_length, hsize_t heap_length, const Validate1dPointersOptions& options) {
    try {
        validate_pointer_datatype(data, std::numeric_limits<Offset_>::digits, std::numeric_limits<Length_>::digits);
    } catch (std::exception& e) {
        throw std::runtime_error("failed to validate the datatype; " + std::string(e.what()));
    }
    assert(data.getSpace().getSimpleExtentNdims() == 1);
 
    const auto& plist = data.getCreatePlist();
    hsize_t block_size = 0;
    if (plist.getLayout() == H5D_CHUNKED) {
        plist.getChunk(1, &block_size);
    } else {
        block_size = std::min(full_length, options.contiguous_chunk_size);
    }
 
    H5::DataSpace mspace(1, &block_size), dspace(1, &full_length);
    auto buffer = sanisizer::create<std::vector<Pointer<Offset_, Length_> > >(block_size);
    auto dtype = define_pointer_datatype<Offset_, Length_>();
 
    hsize_t i = 0;
    while (i < full_length) {
        const auto available = sanisizer::min(full_length - i, block_size);
        constexpr hsize_t zero = 0;
        mspace.selectHyperslab(H5S_SELECT_SET, &available, &zero);
        dspace.selectHyperslab(H5S_SELECT_SET, &available, &i);
 
        data.read(buffer.data(), dtype, mspace, dspace);
        for (I<decltype(available)> j = 0; j < available; ++j) {
            const auto& val = buffer[j];
            if (is_Pointer_out_of_range(val, heap_length)) {
                throw std::runtime_error("pointer at position " + itoa(i + j) + " is out of range of the heap");
            }
        }
 
        i += available;
    }
}
 
struct ValidateNdPointersOptions {
    hsize_t contiguous_chunk_size = sanisizer::cap<hsize_t>(10000);
};
 
template<typename Offset_, typename Length_>
void validate_nd_pointers(const H5::DataSet& data, const std::vector<hsize_t>& dimensions, hsize_t heap_length, const ValidateNdPointersOptions& options) {
    try {
        validate_pointer_datatype(data, std::numeric_limits<Offset_>::digits, std::numeric_limits<Length_>::digits);
    } catch (std::exception& e) {
        throw std::runtime_error("failed to validate the datatype; " + std::string(e.what()));
    }
    assert(data.getSpace().getSimpleExtentNdims() > 0);
 
    // Cast of 'ndim' to 'int' is implicitly safe if the assertion holds.
    const auto ndim = dimensions.size();
    assert(sanisizer::is_equal(ndim, data.getSpace().getSimpleExtentNdims()));
 
    std::vector<hsize_t> chunk_dims;
    const auto& plist = data.getCreatePlist();
    if (plist.getLayout() == H5D_CHUNKED) {
        chunk_dims.resize(ndim); // No need to check this, dimensions is of the same type as chunk_dims.
        plist.getChunk(ndim, chunk_dims.data());
    } else {
        chunk_dims = hdf5::mock_contiguous_chunks(dimensions, options.contiguous_chunk_size);
    }
 
    hdf5::IterateChunks iter(dimensions, chunk_dims);
    H5::DataSpace fspace(ndim, dimensions.data());
    H5::DataSpace mspace(ndim, iter.chunk_dimensions().data());
    auto buffer = sanisizer::create<std::vector<Pointer<Offset_, Length_> > >(mspace.getSimpleExtentNpoints());
    auto dtype = define_pointer_datatype<Offset_, Length_>();
 
    while (iter.advance()) {
        const auto& curcount = iter.counts();
        const auto& curstart = iter.starts();
        mspace.setExtentSimple(ndim, curcount.data());
        fspace.selectHyperslab(H5S_SELECT_SET, curcount.data(), curstart.data());
 
        data.read(buffer.data(), dtype, mspace, fspace);
        const auto available = mspace.getSimpleExtentNpoints();
        for (I<decltype(available)> i = 0; i < available; ++i) {
            const auto& val = buffer[i];
            if (is_Pointer_out_of_range(val, heap_length)) {
                auto posstr = hdf5::emit_coordinates_as_string(i, available, curstart, curcount);
                throw std::runtime_error("pointer at position " + posstr + " is out of range of the heap");
            }
        }
    }
}
 
inline hsize_t validate_heap(const H5::DataSet& data) {
    if (data.getTypeClass() != H5T_INTEGER) {
        throw std::runtime_error("expected an integer datatype");
    }
    if (hdf5::exceeds_integer_limit(data.getIntType(), 8, false)) {
        throw std::runtime_error("expected 8-bit unsigned integers");
    }
    auto dspace = data.getSpace();
    if (dspace.getSimpleExtentNdims() != 1) {
        throw std::runtime_error("expected a 1-dimensional dataset");
    }
    hsize_t len;
    dspace.getSimpleExtentDims(&len);
    return len;
}
 
}
 
}
 
#endif