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) {
    if (itype.getSign() == 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 (is_signed) {
            return (itype.getPrecision() > precision);
        } else {
            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