mgl_range.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_RANGE_H_1746895769
#define INCGUARD_MGL_RANGE_H_1746895769
 
#include <algorithm>
#include <limits>
#include <type_traits>
 
namespace MGL
{
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
template <class T>
class Range
{
public:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Range() noexcept = default;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Range(T begin, T end) noexcept
        : _begin(begin)
        , _end(end)
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T Begin() const noexcept
    {
        return _begin;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T End() const noexcept
    {
        return _end;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsPositive() const noexcept
    {
        return _begin < _end;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsNegative() const noexcept
    {
        return !IsPositive();
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsSingleValue() const noexcept
    {
        if constexpr (std::is_floating_point_v<T>)
        {
            return _end - _begin <= std::numeric_limits<T>::epsilon();
        }
        else
        {
            return _begin == _end;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsZero() const noexcept
    {
        if constexpr (std::is_floating_point_v<T>)
        {
            return std::abs(_begin) <= std::numeric_limits<T>::epsilon() &&
                   std::abs(_end) <= std::numeric_limits<T>::epsilon();
        }
        else
        {
            return _begin == 0 && _end == 0;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T Next(T value) const noexcept
    {
        if (IsPositive() || IsSingleValue())
        {
            return ++value;
        }
        else
        {
            return --value;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T Previous(T value) const noexcept
    {
        if (IsPositive() || IsSingleValue())
        {
            return --value;
        }
        else
        {
            return ++value;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool Contains(T value) const noexcept
    {
        if (IsPositive() || IsSingleValue())
        {
            return (value >= _begin) && (value <= _end);
        }
        else
        {
            return (value <= _begin) && (value >= _end);
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T Clamp(T value) const noexcept
    {
        if (IsSingleValue())
        {
            return _begin;
        }
        else if (IsPositive())
        {
            return std::clamp(value, _begin, _end);
        }
        else
        {
            return std::clamp(value, _end, _begin);
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr float Normalize(T value) const noexcept
    {
        if (IsSingleValue())
        {
            return 1.0f;
        }
 
        const auto fBegin = static_cast<float>(_begin);
        const auto fEnd = static_cast<float>(_end);
        const auto fValue = static_cast<float>(value);
 
        return (fValue - fBegin) / (fEnd - fBegin);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr T Scale(float normalizedValue) const noexcept
    {
        const auto fBegin = static_cast<float>(_begin);
        const auto fEnd = static_cast<float>(_end);
 
        return static_cast<T>(fBegin + ((fEnd - fBegin) * normalizedValue));
    }
 
private:
    T _begin{0};
    T _end{0};
};
}    // namespace MGL
 
#endif    // INCGUARD_MGL_RANGE_H_1746895769
 
// vim: et ts=4 sw=4 sts=4