exceeds_limit.hpp

Go to the documentation of this file.

#ifndef RITSUKO_HDF5_FORBID_LARGE_INTEGERS_HPP
#define RITSUKO_HDF5_FORBID_LARGE_INTEGERS_HPP
 
#include "H5Cpp.h"
 
#include <stdexcept>
#include <cstddef>
 
namespace ritsuko {
 
namespace hdf5 {
 
inline bool exceeds_integer_limit(const H5::IntType& itype, std::size_t precision, bool is_signed) {
    const auto sign = itype.getSign(); 
    if (sign == H5T_SGN_NONE) {
        if (is_signed) {
            return (itype.getPrecision() >= precision); // equality, as one bit of the limiting type is used for the sign.
        } else {
            return (itype.getPrecision() > precision);
        }
    } else if (sign == H5T_SGN_2) {
        if (is_signed) {
            return (itype.getPrecision() > precision);
        } else {
            return true;
        }
    } else {
        // Some other as-yet-unsupported integer type (1's complement, perhaps?)
        // so we'll just err on the side of caution and say it doesn't fit in the limiting unsigned or 2's complement integer.
        return true;
    }
}
 
inline bool exceeds_integer_limit(const H5::DataSet& data, std::size_t precision, bool is_signed) {
    if (data.getTypeClass() != H5T_INTEGER) {
        return true;
    }
    H5::IntType itype(data);
    return exceeds_integer_limit(itype, precision, is_signed);
}
 
inline bool exceeds_integer_limit(const H5::Attribute& attr, std::size_t precision, bool is_signed) {
    if (attr.getTypeClass() != H5T_INTEGER) {
        return true;
    }
    return exceeds_integer_limit(attr.getIntType(), precision, is_signed);
}
 
inline bool exceeds_float_limit_by_integer(const H5::IntType& itype, std::size_t precision) {
    if (precision >= 64) {
        return exceeds_integer_limit(itype, 53, true);
    } else if (precision >= 32) {
        return exceeds_integer_limit(itype, 24, true);
    } else {
        return true;
    }
}
 
inline bool exceeds_float_limit_by_float(const H5::FloatType& ftype, std::size_t precision) {
    // Only considering IEEE-compatible types here.
    if (precision >= 64) {
        return !(
            ftype == H5::PredType::IEEE_F64LE || 
            ftype == H5::PredType::IEEE_F64BE ||
            ftype == H5::PredType::IEEE_F32LE || 
            ftype == H5::PredType::IEEE_F32BE
        );
    } else if (precision >= 32) {
        return !(
            ftype == H5::PredType::IEEE_F32LE || 
            ftype == H5::PredType::IEEE_F32BE
        );
    } else {
        return true;
    }
}
inline bool exceeds_float_limit(const H5::DataSet& data, std::size_t precision) {
    auto tclass = data.getTypeClass();
    if (tclass == H5T_INTEGER) {
        return exceeds_float_limit_by_integer(H5::IntType(data), precision);
    } else if (tclass == H5T_FLOAT) {
        return exceeds_float_limit_by_float(H5::FloatType(data), precision);
    } else {
        return true;
    }
}
 
inline bool exceeds_float_limit(const H5::Attribute& attr, std::size_t precision) {
    auto tclass = attr.getTypeClass();
    if (tclass == H5T_INTEGER) {
        return exceeds_float_limit_by_integer(attr.getIntType(), precision);
    } else if (tclass == H5T_FLOAT) {
        return exceeds_float_limit_by_float(attr.getFloatType(), precision);
    } else {
        return true;
    }
}
 
}
 
}
 
#endif