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