validate_string.hpp

Go to the documentation of this file.

#ifndef RITSUKO_HDF5_VALIDATE_STRING_HPP
#define RITSUKO_HDF5_VALIDATE_STRING_HPP
 
#include <string>
#include <vector>
#include <stdexcept>
#include <cassert>
#include <algorithm>
 
#include "H5Cpp.h"
#include "sanisizer/sanisizer.hpp"
 
#include "mock_contiguous_chunks.hpp"
#include "IterateChunks.hpp"
#include "ReclaimVlsMemory.hpp"
#include "../itoa.hpp"
 
namespace ritsuko {
 
namespace hdf5 {
 
inline void validate_scalar_string(const H5::DataSet& data) {
    assert(data.getSpace().getSimpleExtentNdims() == 0);
    assert(data.getDataType().getClass() == H5T_STRING);
 
    auto dtype = data.getDataType();
    if (!dtype.isVariableStr()) {
        return;
    }
 
    char* vptr = NULL;
    data.read(&vptr, dtype);
 
    const auto& dspace = data.getSpace();
    const auto& plist = H5::DSetMemXferPropList::DEFAULT;
    [[maybe_unused]] ReclaimVlsMemory deletor(&dtype, &dspace, &plist, &vptr);
 
    if (vptr == NULL) {
        throw std::runtime_error("detected a NULL pointer for a variable length string");
    }
}
 
struct Validate1dStringsOptions {
    hsize_t contiguous_chunk_size = sanisizer::cap<hsize_t>(10000);
};
 
inline void validate_1d_strings(const H5::DataSet& data, hsize_t full_length, const Validate1dStringsOptions& options) {
    assert(data.getSpace().getSimpleExtentNdims() == 1);
    assert(data.getDataType().getClass() == H5T_STRING);
 
    auto dtype = data.getDataType();
    if (!dtype.isVariableStr()) {
        return;
    }
 
    hsize_t block_size;
    const auto& plist = data.getCreatePlist();
    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<char*> >(block_size);
 
    hsize_t pos = 0;
    while (true) {
        const hsize_t available = sanisizer::min(full_length - pos, block_size);
        if (available == 0) {
            break;
        }
 
        constexpr hsize_t zero = 0;
        mspace.selectHyperslab(H5S_SELECT_SET, &available, &zero);
        dspace.selectHyperslab(H5S_SELECT_SET, &available, &pos);
        data.read(buffer.data(), dtype, mspace, dspace);
 
        const auto& plist = H5::DSetMemXferPropList::DEFAULT;
        [[maybe_unused]] ReclaimVlsMemory deletor(&dtype, &mspace, &plist, buffer.data());
        for (hsize_t i = 0; i < available; ++i) {
            if (buffer[i] == NULL) {
                throw std::runtime_error("detected a NULL pointer for a variable length string at position " + itoa(pos + i));
            }
        }
 
        pos += available;
    }
}
 
struct ValidateNdStringsOptions {
    hsize_t contiguous_chunk_size = sanisizer::cap<hsize_t>(10000);
};
 
inline void validate_nd_strings(const H5::DataSet& data, const std::vector<hsize_t>& dimensions, const ValidateNdStringsOptions& options) {
    assert(data.getSpace().getSimpleExtentNdims() > 0);
    assert(data.getDataType().getClass() == H5T_STRING);
 
    auto stype = data.getDataType();
    if (!stype.isVariableStr()) {
        return;
    }
 
    // Cast of 'ndims' to 'int' is implicitly safe if the assertion holds.
    const auto ndims = dimensions.size();
    assert(sanisizer::is_equal(ndims, data.getSpace().getSimpleExtentNdims()));
 
    std::vector<hsize_t> chunk_dims;
    const auto& plist = data.getCreatePlist();
    if (plist.getLayout() == H5D_CHUNKED) {
        chunk_dims.resize(ndims); // this is safe as 'dimensions' and 'chunk_dims' have the same size_type.
        plist.getChunk(dimensions.size(), chunk_dims.data());
    } else {
        chunk_dims = mock_contiguous_chunks(dimensions, options.contiguous_chunk_size);
    }
 
    IterateChunks iter(dimensions, chunk_dims);
 
    const auto ndim = dimensions.size();
    H5::DataSpace fspace(ndim, dimensions.data());
    H5::DataSpace mspace(ndim, iter.chunk_dimensions().data());
    auto buffer = sanisizer::create<std::vector<char*> >(mspace.getSimpleExtentNpoints());
 
    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(), stype, mspace, fspace);
        const auto& plist = H5::DSetMemXferPropList::DEFAULT;
        [[maybe_unused]] ReclaimVlsMemory deleter(&stype, &mspace, &plist, buffer.data());
 
        const auto npts = mspace.getSimpleExtentNpoints();
        for (I<decltype(npts)> i = 0; i < npts; ++i) {
            if (buffer[i] == NULL) {
                auto posstr = emit_coordinates_as_string(i, npts, curstart, curcount);
                throw std::runtime_error("detected NULL pointer for a variable-length string at position " + posstr);
            }
        }
    }
}
 
inline void validate_scalar_string(const H5::Attribute& attr) {
    assert(attr.getSpace().getSimpleExtentNdims() == 0);
    assert(attr.getDataType().getClass() == H5T_STRING);
 
    auto dtype = attr.getDataType();
    if (!dtype.isVariableStr()) {
        return;
    }
 
    const auto& mspace = attr.getSpace();
    const auto& plist = H5::DSetMemXferPropList::DEFAULT; // yes, even H5Aread uses H5P_DATASET_XFER_DEFAULT.
    char* buffer;
    attr.read(dtype, &buffer);
    [[maybe_unused]] ReclaimVlsMemory deletor(&dtype, &mspace, &plist, &buffer);
    if (buffer == NULL) {
        throw std::runtime_error("detected a NULL pointer for a variable length string");
    }
}
 
inline void validate_1d_strings(const H5::Attribute& attr, hsize_t full_length) {
    assert(attr.getSpace().getSimpleExtentNdims() == 1);
    assert(attr.getDataType().getClass() == H5T_STRING);
 
    auto dtype = attr.getDataType();
    if (!dtype.isVariableStr()) {
        return;
    }
 
    const auto& mspace = attr.getSpace();
    const auto& plist = H5::DSetMemXferPropList::DEFAULT; // yes, even H5Aread uses H5P_DATASET_XFER_DEFAULT.
    auto buffer = sanisizer::create<std::vector<char*> >(full_length);
    attr.read(dtype, buffer.data());
    [[maybe_unused]] ReclaimVlsMemory deletor(&dtype, &mspace, &plist, buffer.data());
    for (hsize_t i = 0; i < full_length; ++i) {
        if (buffer[i] == NULL) {
            throw std::runtime_error("detected a NULL pointer for a variable length string");
        }
    }
}
 
}
 
}
 
#endif