Pointer.hpp

Go to the documentation of this file.

#ifndef RITSUKO_CVLS_POINTER_HPP
#define RITSUKO_CVLS_POINTER_HPP
 
#include <stdexcept>
#include <string>
#include <cstddef>
#include <limits>
 
#include "H5Cpp.h"
#include "sanisizer/sanisizer.hpp"
 
#include "../hdf5/as_numeric_datatype.hpp"
#include "../hdf5/exceeds_limit.hpp"
#include "../hdf5/get_name.hpp"
 
namespace ritsuko {
 
namespace cvls {
 
template<typename Offset_, typename Length_>
struct Pointer {
    Offset_ offset;
 
    Length_ length;
 
    static_assert(std::is_integral<Offset_>::value);
    static_assert(std::is_unsigned<Offset_>::value);
    static_assert(std::is_integral<Length_>::value);
    static_assert(std::is_unsigned<Length_>::value);
};
 
template<typename Offset_, typename Length_>
H5::CompType define_pointer_datatype() {
    typedef Pointer<Offset_, Length_> tmp;
    H5::CompType pointer_type(sizeof(tmp));
    pointer_type.insertMember("offset", HOFFSET(tmp, offset), hdf5::as_numeric_datatype<Offset_>());
    pointer_type.insertMember("length", HOFFSET(tmp, length), hdf5::as_numeric_datatype<Length_>());
    return pointer_type;
}
 
inline void validate_pointer_datatype(const H5::CompType& type, const std::size_t offset_precision, const std::size_t length_precision) {
    if (type.getNmembers() != 2) {
        throw std::runtime_error("expected compressed VLS compound datatype to have two members");
    }
 
    if (type.getMemberName(0) != "offset") {
        throw std::runtime_error("first member of a compressed VLS compound datatype should be named 'offset'");
    }
    if (type.getMemberClass(0) != H5T_INTEGER) {
        throw std::runtime_error("first member of a compressed VLS compound datatype should have integer type");
    }
    auto offset_type = type.getMemberIntType(0);
    if (hdf5::exceeds_integer_limit(offset_type, offset_precision, false)) {
        throw std::runtime_error("first member of a compressed VLS compound datatype should not exceed a " + std::to_string(offset_precision) + "-bit unsigned integer");
    }
 
    if (type.getMemberName(1) != "length") {
        throw std::runtime_error("second member of a compressed VLS compound datatype should be named 'length'");
    }
    if (type.getMemberClass(1) != H5T_INTEGER) {
        throw std::runtime_error("second member of a compressed VLS compound datatype should have integer type");
    }
    auto length_type = type.getMemberIntType(1);
    if (hdf5::exceeds_integer_limit(length_type, length_precision, false)) {
        throw std::runtime_error("second member of a VLS compound datatype should not exceed a " + std::to_string(length_precision) + "-bit unsigned integer");
    }
}
 
inline void validate_pointer_datatype(const H5::DataSet& data, const std::size_t offset_precision, const std::size_t length_precision) {
    if (data.getTypeClass() != H5T_COMPOUND) {
        throw std::runtime_error("expected a compound datatype for a compressed VLS pointer dataset at '" + hdf5::get_name(data) + "'");
    }
 
    try {
        validate_pointer_datatype(data.getCompType(), offset_precision, length_precision);
    } catch (std::exception& e) {
        std::string msg = e.what();
        msg += " in '" + hdf5::get_name(data) + "'";
        throw std::runtime_error(msg.c_str());
    }
}
 
template<typename Offset_, typename Length_>
bool is_Pointer_out_of_range(const Pointer<Offset_, Length_>& ptr, const hsize_t heap_length) {
    // Some finesse is required here to avoid computing offset + length, as that might overflow.
    return sanisizer::is_greater_than(ptr.offset, heap_length) || sanisizer::is_greater_than(ptr.length, heap_length - ptr.offset);
}
 
}
 
}
 
#endif