tb_defines.hpp

#ifndef TurtleBrains_Defines_hpp
#define TurtleBrains_Defines_hpp

#include <limits>
#include <type_traits>

#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_error.hpp>


#define tb_unused(parameter)    ((void)parameter);

namespace TurtleBrains
{
    namespace Core
    {
        template <typename Type> void SafeDelete(Type*& objectPointer) { if (nullptr != objectPointer) { delete objectPointer; objectPointer = nullptr; } }

        template <typename Type> void SafeDeleteArray(Type*& arrayPointer) { if (nullptr != arrayPointer) { delete[] arrayPointer; arrayPointer = nullptr; } }


        template <typename ReturnType, typename InitialType> ReturnType RangedCast(const InitialType& value)
        {
#if defined(tb_visual_cpp)
  #pragma warning(push)
            //We are removing 2 warnings here:
            //  4127: Constant Expression with first part of if, because it is constant ... but we only care about that at
            //      compile time, so it doesn't matter. The C++17 if constexpr (expression) could fix this (and the next).
            //  4018: Signed/Unsigned Mismatch with the second part (inside the top if statement) because the compiler is
            //      still generating the code for the error checks, and the signs are mismatching. We just don't care since
            //      the code flow would jump to the bottom when those warnings would apply.
            //  Note: Both of these should be fixed in C++17 by using if constexpr () since that would let the compiler
            //      see the actual intent, and remove the error check completely when signs are mismatched.
  #pragma warning(disable: 4127)
  #pragma warning(disable: 4018)
#elif defined(__GNUC__)
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wsign-compare"
#endif
            if ((std::is_signed<ReturnType>::value == std::is_signed<InitialType>::value))
            {
                tb_error_if(value < std::numeric_limits<ReturnType>::min() || value > std::numeric_limits<ReturnType>::max(),
                    "tbCastingError: Value is outside the range of the following cast.");
            }
            else if (std::is_signed<InitialType>::value)
            {
                tb_error_if(value < 0, "tbCastingError: Signed value is less than 0 going to unsigned-value.");
            }
#if defined(tb_visual_cpp)
  #pragma warning(pop)
#elif defined(__GNUC__)
  #pragma GCC diagnostic pop
#endif
            return static_cast<ReturnType>(value);
        }

        template <typename ReturnType, typename InitialType> ReturnType ClampedCast(const InitialType& value, const ReturnType& minimum, const ReturnType& maximum)
        {
            tb_error_if(minimum > maximum, "tbError: Minimum should never be larger than Maximum.");
            ReturnType unclamped = RangedCast<ReturnType>(value);
            if (unclamped < minimum)
            {
                return minimum;
            }
            if (unclamped > maximum)
            {
                return maximum;
            }
            return unclamped;
        }

    }; /* namespace Core */

}; /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;


#endif /* TurtleBrains_Defines_hpp */