tb_typed_integer.hpp

 
#ifndef TurtleBrains_TypedInteger_hpp
#define TurtleBrains_TypedInteger_hpp
 
#include <type_traits>
#include <functional>
 
namespace TurtleBrains::Core
{
 
    template<typename Type, typename std::underlying_type<Type>::type defaultValue = typename std::underlying_type<Type>::type(0)> struct TypedInteger
    {
    public:
        using Integer = typename std::underlying_type<Type>::type;
 
        constexpr inline TypedInteger(const Integer value = defaultValue) :
            mValue(value)
        {
        }
 
        constexpr inline operator Integer(void) const { return Integer(mValue); }
 
        //inline TypedInteger::Integer operator+(int value) const { return mValue + value; }
        //inline TypedInteger::Integer operator-(int value) const { return mValue - value; }
 
        inline constexpr TypedInteger::Integer operator+(TypedInteger::Integer value) const { return mValue + value; }
        inline TypedInteger::Integer operator+=(TypedInteger::Integer value) { return mValue += value; }
        inline TypedInteger::Integer operator++(void) { return ++mValue; }
        inline TypedInteger::Integer operator++(int) { return mValue++; }
 
        inline constexpr TypedInteger::Integer operator-(TypedInteger::Integer value) const { return mValue - value; }
        inline TypedInteger::Integer operator-=(TypedInteger::Integer value) { return mValue -= value; }
        inline TypedInteger::Integer operator--(void) { return --mValue; }
        inline TypedInteger::Integer operator--(int) { return mValue--; }
 
    private:
        Integer mValue;
    };
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
//--------------------------------------------------------------------------------------------------------------------//
 
// 2025-11-09: This fixes an issue where std::unordered_map<TypedInteger> would complain about the std::hash not being
//   defined/usable. It does have to be in global space to work.
template<typename Type> struct std::hash<TurtleBrains::Core::TypedInteger<Type>>
{
    std::size_t operator()(const TurtleBrains::Core::TypedInteger<Type>& value) const noexcept
    {
        return std::hash<typename TurtleBrains::Core::TypedInteger<Type>::Integer>{}(value);
    }
};
 
#endif /* TurtleBrains_TypedInteger_hpp */