priority.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <string_view>
 
namespace contur {

    enum class PriorityLevel : std::int8_t
    {
        Realtime = 0,    
        High = 1,        
        AboveNormal = 2, 
        Normal = 3,      
        BelowNormal = 4, 
        Low = 5,         
        Idle = 6,        
    };

    constexpr std::int32_t NICE_MIN = -20;

    constexpr std::int32_t NICE_MAX = 19;

    constexpr std::int32_t NICE_DEFAULT = 0;

    struct Priority
    {
        PriorityLevel base = PriorityLevel::Normal;      
        PriorityLevel effective = PriorityLevel::Normal; 
        std::int32_t nice = NICE_DEFAULT;                

        constexpr Priority() noexcept = default;

        constexpr explicit Priority(PriorityLevel level) noexcept
            : base(level)
            , effective(level)
            , nice(NICE_DEFAULT)
        {}

        constexpr Priority(PriorityLevel base, PriorityLevel effective, std::int32_t nice) noexcept
            : base(base)
            , effective(effective)
            , nice(clampNice(nice))
        {}

        [[nodiscard]] constexpr bool operator==(const Priority &other) const noexcept
        {
            return base == other.base && effective == other.effective && nice == other.nice;
        }

        [[nodiscard]] constexpr bool operator!=(const Priority &other) const noexcept
        {
            return !(*this == other);
        }

        [[nodiscard]] constexpr bool isHigherThan(const Priority &other) const noexcept
        {
            if (effective != other.effective)
            {
                return static_cast<std::int8_t>(effective) < static_cast<std::int8_t>(other.effective);
            }
            return nice < other.nice;
        }

        [[nodiscard]] static constexpr std::int32_t clampNice(std::int32_t value) noexcept
        {
            if (value < NICE_MIN)
            {
                return NICE_MIN;
            }
            if (value > NICE_MAX)
            {
                return NICE_MAX;
            }
            return value;
        }
    };

    [[nodiscard]] constexpr std::string_view priorityLevelName(PriorityLevel level) noexcept
    {
        switch (level)
        {
        case PriorityLevel::Realtime:
            return "Realtime";
        case PriorityLevel::High:
            return "High";
        case PriorityLevel::AboveNormal:
            return "AboveNormal";
        case PriorityLevel::Normal:
            return "Normal";
        case PriorityLevel::BelowNormal:
            return "BelowNormal";
        case PriorityLevel::Low:
            return "Low";
        case PriorityLevel::Idle:
            return "Idle";
        }
        return "Unknown";
    }
 
} // namespace contur