RangeNum.hpp

[詳解]

#pragma once
 
/**
 * @file RangeNum.hpp
 * @brief 範囲指定の値型を提供します。
 * @author 樺澤陽向
 * @date 2025/05/07
 * @since 1.0.0
 */
 
#include <cassert>
#include <cmath>
#include "../ConsoleDebug/Debug.hpp"
 
namespace Kisaragi_Lib
{
    /// <summary>
    /// 範囲外の入力された値をどのように扱うかを決定するPolicyのベース型
    /// </summary>
    /// @since 1.0.0
    struct IOutOfRange{};
 
    /// <summary>
    /// 範囲外が与えられたら即座に終了
    /// </summary>
    /// @since 1.0.0
    struct ThrowOnOutOfRange : public IOutOfRange
    {
        template<typename T>
        static void Handle(const T& _value, const T& _min, const T& _max) 
        {
            assert((_value < _min || _value > _max) && "RangeNum: 値が範囲外です");
        }
    };
 
    /// <summary>
    /// 範囲外が与えられたら近い範囲内に自動修正
    /// </summary>
    /// @since 1.0.0
    struct ClampOnOutOfRange : public IOutOfRange
    {
        template<typename T>
        static void Handle(T& _value, const T& _min, const T& _max) 
        {
            if (_value < _min)
            {
                _value = _min;
            }
            else if (_value > _max)
            {
                _value = _max;
            }
        }
    };
 
    /// <summary>
    /// 範囲外が与えられたら警告のみ出力
    /// </summary>
    /// @since 1.0.0
    struct IgnoreOutOfRange : public IOutOfRange
    {
        template<typename T>
        static void Handle(const T& _value, const T& _min, const T& _max) 
        {
            if (_value < _min || _value > _max) 
            {
                Debug::PrintAssertStatic( "Warning: 範囲外の値 " + _value + " が渡されました");
            }
        }
    };
 
    /// <summary>
    /// 範囲外が与えられたらループした値に戻す
    /// </summary>
    /// @since 1.1.1
    struct LoopOutOfRange : public IOutOfRange
    {
            template<typename T,
                std::enable_if_t<std::is_integral<T>::value,int> = 0>
            static void Handle(T& _value, const T& _min, const T& _max)
            {
                T range = _max - _min + 1;  // 範囲の幅 (max含む場合)
 
                if (range <= 0)
                {
                    return;     // 範囲がおかしい場合は処理しない
                }
 
                auto positive_mod = [](T a, T b) -> T 
                    {
                    T r = a % b;
                    return (r < 0) ? r + b : r;
                    };
 
                // _value を _min から始まる範囲内にループさせる
                _value = positive_mod(_value - _min, range) + _min;
            }
 
            template<typename T,
                std::enable_if_t<std::is_floating_point_v<T>,int> = 0>
            static void Handle(T& _value, const T& _min, const T& _max)
            {
                T range = _max - _min;
                if (range <= 0) return;
 
                T offset = std::fmod(_value - _min, range);
                if (offset < 0)
                    offset += range;
 
                _value = _min + offset;
            }
    };
 
 
    /// <summary>
    /// 特定範囲の値を管理するための数値型
    /// </summary>
    /// <typeparam name="T">値型の型</typeparam>
    /// <typeparam name="Policy">IOutOfRange派生型</typeparam>
    /// @since 1.0.0
    template<typename T, typename Policy>
    class RangeNum
    {
        // Tが値型か検証
        static_assert(std::is_arithmetic<T>::value, "RangeNum には数値型を渡してください");
 
        // Policy が IOutOfRange の派生型であることを検証
        static_assert(std::is_base_of<IOutOfRange, Policy>::value, "Policy は IOutOfRange の派生型でなくてはなりません");
 
        // IOutOfRangeを渡されていないか確認
        static_assert(!std::is_same<IOutOfRange, Policy>::value, "Policy に IOutOfRange を渡すことはできません");
 
    private:
        /// <summary>
        /// 値
        /// </summary>
        T value;
 
        /// <summary>
        /// 最小値
        /// </summary>
        T MIN;
 
        /// <summary>
        /// 最大値
        /// </summary>
        T MAX;
 
        // 値をチェックして設定
        void Assign(T& _v) 
        {
            Policy::Handle(_v, MIN, MAX);
            value = _v;
        }
 
    public:
        // コンストラクタ
        RangeNum(T min, T max) : MIN(min), MAX(max), value(min)
        {
            assert(MIN <= MAX && "RangeNum : MINの値がMAX以上です。");
        }
 
        // 値型から直接構築
        RangeNum(T min, T max, T init) : MIN(min), MAX(max)
        {
            assert(MIN <= MAX && "RangeNum : MINの値がMAX以上です。");
            Assign(init);
        }
 
        // コピーコンストラクタ
        RangeNum(const RangeNum& other) = default;
 
        // 暗黙変換：T に変換できる（get() の代わり）
        operator T() const { return value; }
 
        RangeNum operator=(T _rhs)
        {
            Assign(_rhs);
            return *this;
        }
        
 
        // 四則演算（RangeNum + T）
        RangeNum operator+(const T& _rhs) const {
            return RangeNum(MIN, MAX, Checked(value + _rhs));
        }
 
        RangeNum operator-(const T& _rhs) const {
            return RangeNum(MIN, MAX, Checked(value - _rhs));
        }
 
        RangeNum operator*(const T& _rhs) const {
            return RangeNum(MIN, MAX, Checked(value * _rhs));
        }
 
        RangeNum operator/(const T& _rhs) const {
            return RangeNum(MIN, MAX, Checked(value / _rhs));
        }
 
        // 代入演算子
        RangeNum& operator+=(const T& _rhs) {
            Assign(value + _rhs);
            return *this;
        }
 
        RangeNum& operator-=(const T& _rhs) {
            Assign(value - _rhs);
            return *this;
        }
 
        RangeNum& operator*=(const T& _rhs) {
            Assign(value * _rhs);
            return *this;
        }
 
        RangeNum& operator/=(const T& _rhs) {
            Assign(value / _rhs);
            return *this;
        }
 
        // 比較演算子
        bool operator==(const RangeNum& _rhs) const { return value == _rhs.value; }
        bool operator!=(const RangeNum& _rhs) const { return value != _rhs.value; }
        bool operator<(const RangeNum& _rhs) const { return value < _rhs.value; }
        bool operator<=(const RangeNum& _rhs) const { return value <= _rhs.value; }
        bool operator>(const RangeNum& _rhs) const { return value > _rhs.value; }
        bool operator>=(const RangeNum& _rhs) const { return value >= _rhs.value; }
 
        // 値型との比較
        bool operator==(const T& _rhs) const { return value == _rhs; }
        bool operator!=(const T& _rhs) const { return value != _rhs; }
        bool operator<(const T& _rhs) const { return value < _rhs; }
        bool operator<=(const T& _rhs) const { return value <= _rhs; }
        bool operator>(const T& _rhs) const { return value > _rhs; }
        bool operator>=(const T& _rhs) const { return value >= _rhs; }
 
    private:
        // 値チェック付き値返却
        T Checked(T& _result)
        {
            Policy::Handle(_result, MIN, MAX);
            return _result;
        }
    };
}