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::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.
        //
        // 2024-07-31: We might want to try using C++17 constexpr as this is in-progress moving towards C++20. But
        //   MSVC on C++20 threw another warning here and I'm setting that to disable;
        //
        //   4244: 'argument': conversion from 'const InitialType' to 'const unsigned short', possible loss of data
        //       which is something we already know is possible and why we've choosen to use RangedCast, as it will
        //       error when the initial value is out of range.
        //
        //   4267: warning C4267 : 'argument' : conversion from 'size_t' to 'uint32', possible loss of data and for
        //       some reason the static cast isn't enough?
  #pragma warning(disable: 4127)
  #pragma warning(disable: 4018)
  #pragma warning(disable: 4244)
  #pragma warning(disable: 4267)
#elif defined(__GNUC__)
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wsign-compare"
#endif
        // 2025-10-02: I don't remember why this check was initially added. I suspect it was to give a better warning
        //   when casting into a TypedInteger since that required Type::Integer to be used. Today however I was using
        //   this to cast double to float, which perhaps doesn't even require any range checks. I think ensuring it
        //   is trivial is the thing that it wants to be.
        //
        //tb_static_error_if(false == std::is_integral<ReturnType>::value, "Expected ReturnType to be an integral type.");
        tb_static_error_if(false == std::is_trivial<ReturnType>::value, "Expected ReturnType to be a trivial/integral/float type.");
 
        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.");
        }
 
        return static_cast<ReturnType>(value);
#if defined(tb_visual_cpp)
  #pragma warning(pop)
#elif defined(__GNUC__)
  #pragma GCC diagnostic pop
#endif
    }
 
    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 TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_Defines_hpp */