to.h

Go to the documentation of this file.

#pragma once
 
#include "limit.h"
#include <cassert>
#include <stdexcept>
 
#ifdef _WIN32
#  ifdef __INTEL_COMPILER
#   pragma warning(disable:2557)
#  else
#   pragma warning(disable:4018)
#  endif
#endif

template <class D,class T>
constexpr D to(const T &t) {
    // SIMPLER VERSION - Just casts back in debug and checks value is the original
    D ret = static_cast<D>(t);
#ifdef _DEBUG
    T back = static_cast<T>(ret);
    if (back != t) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    return ret;
}
 
// Checking to see if you get the same value back does not work if floating point is used (rounding).
//  Now use a different template override for double/float.
template <>
inline constexpr float to(const double& t) {
    float f = static_cast<float>(t);
#ifdef _DEBUG
    double back = f;
    if (back != t) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    return f;
}
template <class D>
constexpr D to(const double& d) {
#ifdef _DEBUG
    if (d > static_cast<double>(limits<D>::max())) 
        throw std::runtime_error("Numeric Conversion error.");
    if (d < static_cast<double>(limits<D>::lowest())) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    // SIMPLER VERSION - Just casts back in debug and checks value is the original
    D ret = static_cast<D>(d);
    return ret;
}
template <class D>
D constexpr to(const float &d) {
#ifdef _DEBUG
    if (d > static_cast<float>(limits<D>::max())) 
        throw std::runtime_error("Numeric Conversion error.");
    if (d < static_cast<float>(limits<D>::lowest())) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    D ret = static_cast<D>(d);
    return ret;
}
template <>
inline constexpr double to(const float &d) {
    double ret = static_cast<double>(d);
    return ret;
}
#ifdef _WIN32
# pragma warning(default:4018)
#endif

template <class D,class T>
D *check_cast(T *t) {
    D *d = (D *)t;
#ifdef _DEBUG
    D *d2 = dynamic_cast<D *>(t);
    assert(d2==d);
#endif
    return d;
}

template <class D,class T>
const D *check_cast(const T *t) {
    const D *d = (const D *)t;
    assert(dynamic_cast<const D *>(t)==d);
    return d;
}

template <class T>
constexpr const T safeDiv(const T num,const T denom) {
    if (!denom) return num;
    return num/denom;
}

// EoF