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

  // 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;
  };

  template<>
  struct _ml_numeric_limits<signed char>
  {
    static const signed char MinValue = SCHAR_MIN;
    static const unsigned char MaxValue = SCHAR_MAX;
  };

  template<>
  struct _ml_numeric_limits<char>
  {
    static const signed char MinValue = CHAR_MIN;
    static const unsigned char MaxValue = CHAR_MAX;
  };

  template<>
  struct _ml_numeric_limits<unsigned short>
  {
    static const signed short MinValue = 0;
    static const unsigned short MaxValue = USHRT_MAX;
  };

  template<>
  struct _ml_numeric_limits<short>
  {
    static const short MinValue = SHRT_MIN;
    static const unsigned short MaxValue = SHRT_MAX;
  };

  template<>
  struct _ml_numeric_limits<unsigned int>
  {
    static const int MinValue = 0;
    static const unsigned int MaxValue = UINT_MAX;
  };

  template<>
  struct _ml_numeric_limits<int>
  {
    static const int MinValue = INT_MIN;
    static const unsigned int MaxValue = INT_MAX;
  };

  template<>
  struct _ml_numeric_limits<unsigned long>
  {
    static const long MinValue = 0;
    static const unsigned long MaxValue = ULONG_MAX;
  };

  template<>
  struct _ml_numeric_limits<long>
  {
    static const long MinValue = LONG_MIN;
    static const unsigned long MaxValue = LONG_MAX;
  };

  template<>
  struct _ml_numeric_limits<unsigned long long>
  {
    static const long long MinValue = 0;
    static const unsigned long long MaxValue = ULLONG_MAX;
  };

  template<>
  struct _ml_numeric_limits<long long>
  {
    static const long long MinValue = LLONG_MIN;
    static const unsigned long long MaxValue = LLONG_MAX;
  };

  #if defined(_ML_COMPILE_RANGE_CASTS_WITH_CHECKS)

    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_RANGE_ERROR_TYPE("_MLRangeCheck::checked_cast", ML_OUT_OF_RANGE, "Invalid numeric cast (range check failed).");
        }
        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_RANGE_ERROR_TYPE("_MLRangeCheck::checked_cast", ML_OUT_OF_RANGE, "Invalid numeric cast (range check failed).");
        }
        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_RANGE_ERROR_TYPE("_MLRangeCheck::checked_cast", ML_OUT_OF_RANGE, "Invalid numeric cast (range check failed).");
        }
        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);
      }
    };

  #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 _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);
        }

      #endif
    #endif
  #endif
#endif