MeVis/Foundation/Sources/MLUtilities/mlRangeCasts.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
#ifndef __mlRangeCasts_H
#define __mlRangeCasts_H

#ifndef __mlTypeDefs_H
#include "mlTypeDefs.h"
#endif
#ifndef __mlErrorMacros_H
#include "mlErrorMacros.h"
#endif
#ifndef __mlErrorOutput_H
#include "mlErrorOutput.h"
#endif

#include "mlSystemWarningsDisable.h"
#include <limits.h>
#include "mlSystemWarningsRestore.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