mlRangeCasts.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2011, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_RANGE_CASTS_H
#define ML_RANGE_CASTS_H
 
 
#include "mlTypeDefs.h"
#include "mlErrorMacros.h"
#include "mlErrorOutput.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <climits>
#include <ThirdPartyWarningsRestore.h>
 
  //#define _ML_COMPILE_RANGE_CASTS_ONLY_AS_CASTS
 
  #define _ML_COMPILE_RANGE_CASTS_WITH_CHECKS
 
  #define _ML_RANGE_ERROR_TYPE         ML_PRINT_FATAL_ERROR
 
  #define _ML_OUTPUT_RANGE_ERROR \
          _ML_RANGE_ERROR_TYPE("_MLRangeCheck::checked_cast", ML_OUT_OF_RANGE, "Invalid numeric cast (range check failed).");
 
//= _ml_numeric_limits ==========================================================================
 
  // The mininums are always returned with the equivalent signed type, while the
  // maximums are returned with the equivalent unsigned type. This is needed so
  // that comparisons of mins or maxs of types with the same size but different
  // signed-ness don't fail (the compiler would cast to one of the types).
  template <typename T>
  struct _ml_numeric_limits;
 
  template<>
  struct _ml_numeric_limits<unsigned char>
  {
    static const signed char MinValue = 0;
    static const unsigned char MaxValue = UCHAR_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<signed char>
  {
    static const signed char MinValue = SCHAR_MIN;
    static const unsigned char MaxValue = SCHAR_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<char>
  {
    static const signed char MinValue = CHAR_MIN;
    static const unsigned char MaxValue = CHAR_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<unsigned short>
  {
    static const signed short MinValue = 0;
    static const unsigned short MaxValue = USHRT_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<short>
  {
    static const short MinValue = SHRT_MIN;
    static const unsigned short MaxValue = SHRT_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<unsigned int>
  {
    static const int MinValue = 0;
    static const unsigned int MaxValue = UINT_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<int>
  {
    static const int MinValue = INT_MIN;
    static const unsigned int MaxValue = INT_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<unsigned long>
  {
    static const long MinValue = 0;
    static const unsigned long MaxValue = ULONG_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<long>
  {
    static const long MinValue = LONG_MIN;
    static const unsigned long MaxValue = LONG_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<unsigned long long>
  {
    static const long long MinValue = 0;
    static const unsigned long long MaxValue = ULLONG_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<long long>
  {
    static const long long MinValue = LLONG_MIN;
    static const unsigned long long MaxValue = LLONG_MAX;
    static const bool isFloat = false;
  };
 
  template<>
  struct _ml_numeric_limits<float>
  {
    // float values can't be compile time constants:
    // static const double MinValue = -FLT_MAX;
    // static const double MaxValue = FLT_MAX;
    static const bool isFloat = true;
  };
 
  template<>
  struct _ml_numeric_limits<double>
  {
    // float values can't be compile time constants:
    // static const double MinValue = -DBL_MAX;
    // static const double MaxValue = DBL_MAX;
    static const bool isFloat = true;
  };
 
 
  #if defined(_ML_COMPILE_RANGE_CASTS_WITH_CHECKS)
 
//= _MLIntegerRangeCheck ========================================================================
 
    template <bool CheckLowerBounds, bool CheckUpperBounds, typename Target, typename Source>
    struct _MLIntegerRangeCheck;
 
    template <typename Target, typename Source>
    struct _MLIntegerRangeCheck<true, true, Target, Source>
    {
      static inline Target checked_cast(Source srcVal)
      {
        if ((srcVal < static_cast<Source>(_ml_numeric_limits<Target>::MinValue)) ||
            (srcVal > static_cast<Source>(_ml_numeric_limits<Target>::MaxValue)))
        {
          _ML_OUTPUT_RANGE_ERROR
        }
        return static_cast<Target>(srcVal);
      }
    };
 
    template <typename Target, typename Source>
    struct _MLIntegerRangeCheck<false, true, Target, Source>
    {
      static inline Target checked_cast(Source srcVal)
      {
        if (srcVal > static_cast<Source>(_ml_numeric_limits<Target>::MaxValue))
        {
          _ML_OUTPUT_RANGE_ERROR
        }
        return static_cast<Target>(srcVal);
      }
    };
 
    template <typename Target, typename Source>
    struct _MLIntegerRangeCheck<true, false, Target, Source>
    {
      static inline Target checked_cast(Source srcVal)
      {
        if (srcVal < static_cast<Source>(_ml_numeric_limits<Target>::MinValue))
        {
          _ML_OUTPUT_RANGE_ERROR
        }
        return static_cast<Target>(srcVal);
      }
    };
 
    template <typename Target, typename Source>
    struct _MLIntegerRangeCheck<false, false, Target, Source>
    {
      static inline Target checked_cast(Source srcVal)
      {
        return static_cast<Target>(srcVal);
      }
    };
 
//= _MLFloatRangeCheck ==========================================================================
 
    // The default float range check does nothing
    template <typename Target, typename Source>
    struct _MLFloatRangeCheck
    {
      static inline Target checked_cast(Source arg)
      {
        return static_cast<Target>(arg);
      }
    };
 
    // Only when casting from double to float a range check is applied
    template<>
    struct _MLFloatRangeCheck<float, double>
    {
      static inline float checked_cast(double arg)
      {
        if ((arg < static_cast<double>(-FLT_MAX)) ||
            (arg > static_cast<double>(FLT_MAX)))
        {
          _ML_OUTPUT_RANGE_ERROR
        }
        return static_cast<float>(arg);
      }
    };
 
//= _MLRangeCheck ===============================================================================
 
    template <bool isTargetFloat, bool isSourceFloat, typename Target, typename Source>
    struct _MLRangeCheck;
 
    // casting integer to integer does (only the necessary) range checks
    template <typename Target, typename Source>
    struct _MLRangeCheck<false, false, Target, Source>
    {
      static inline Target checked_cast(Source arg)
      {
        return _MLIntegerRangeCheck<(_ml_numeric_limits<Target>::MinValue > _ml_numeric_limits<Source>::MinValue),
                                    (_ml_numeric_limits<Target>::MaxValue < _ml_numeric_limits<Source>::MaxValue),
                                    Target, Source>
                ::checked_cast(arg);
      }
    };
 
    // casting integer to float does no range checks
    template <typename Target, typename Source>
    struct _MLRangeCheck<true, false, Target, Source>
    {
      static inline Target checked_cast(Source arg)
      {
        return static_cast<Target>(arg);
      }
    };
 
    // casting float to integer does range checks
    template <typename Target, typename Source>
    struct _MLRangeCheck<false, true, Target, Source>
    {
      static inline Target checked_cast(Source arg)
      {
        arg = floor(arg + 0.5f);
        if ((arg < static_cast<Source>(_ml_numeric_limits<Target>::MinValue)) ||
            (arg > static_cast<Source>(_ml_numeric_limits<Target>::MaxValue)))
        {
          _ML_OUTPUT_RANGE_ERROR
        }
        return static_cast<Target>(arg);
      }
    };
 
    template <typename Target, typename Source>
    struct _MLRangeCheck<true, true, Target, Source>
    {
      static inline Target checked_cast(Source arg)
      {
        return _MLFloatRangeCheck<Target, Source>::checked_cast(arg);
      }
    };
 
  #endif
 
//===============================================================================================
 
  //----------------------------------------------
  //----------------------------------------------
  #if defined(_ML_COMPILE_RANGE_CASTS_ONLY_AS_CASTS) && defined(_ML_COMPILE_RANGE_CASTS_WITH_CHECKS)
    #error "_ML_COMPILE_RANGE_CASTS_ONLY_AS_CASTS and _ML_COMPILE_RANGE_CAST_FUNCTIONS_WITH_CHECKS must not be set both."
  #else
    #if !defined(_ML_COMPILE_RANGE_CASTS_ONLY_AS_CASTS) && !defined(_ML_COMPILE_RANGE_CASTS_WITH_CHECKS)
      // Compilation is disabled - so just insert original statements instead of function calls.
 
      template<Target, Source>
      inline Target mlrange_cast(Source arg) { return arg; }
 
    #else
 
      #if defined(_ML_COMPILE_RANGE_CASTS_ONLY_AS_CASTS)
        // Compilation is enabled, but checks are disabled for maximum performance. Just insert casts then.
 
        template<Target, Source>
        inline Target mlrange_cast(Source arg) { return static_cast<Target>(arg); }
 
      #else
        // Compilation is enabled with checks. Insert check function calls.
 
        template<typename Target, typename Source>
        inline Target mlrange_cast(Source arg)
        {
          return _MLRangeCheck<_ml_numeric_limits<Target>::isFloat,
                               _ml_numeric_limits<Source>::isFloat,
                               Target, Source>
                 ::checked_cast(arg);
        }
 
      #endif
    #endif
  #endif
#endif