value.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_VALUE_VALUE_H
#define pRC_CORE_VALUE_VALUE_H
 
#include <prc/config.hpp>
#include <prc/core/basic/concepts.hpp>
 
namespace pRC
{
    template<Size Width = DEFAULT_FLOAT>
    class Float;
 
    template<Bool S = true, Size Width = sizeof(int) * 8>
    class Integer;
 
    template<Size W = sizeof(int) * 8>
    using SignedInteger = Integer<true, W>;
 
    template<Size W = sizeof(int) * 8>
    using UnsignedInteger = Integer<false, W>;
 
    template<class T>
    concept IsFloat = !IsReference<T> && requires {
        {
            []<Size W>(Float<W> const &&)
            {
            }(std::declval<T>())
        };
    };
 
    template<class T>
    concept IsInteger = !IsReference<T> && requires {
        {
            []<Bool S, Size W>(Integer<S, W> const &&)
            {
            }(std::declval<T>())
        };
    };
 
    template<class T>
    concept IsSignedInteger =
        IsInteger<T> && requires { requires(T::Signed == true); };
 
    template<class T>
    concept IsUnsignedInteger =
        IsInteger<T> && requires { requires(T::Signed == false); };
 
    template<class T>
    concept IsValue = IsFloat<T> || IsInteger<T>;
 
    template<class T>
    struct ValueType
    {
        using Type = Undefined;
    };
 
    template<IsValue T>
    struct ValueType<T>
    {
        using Type = RemoveConst<T>;
    };
 
    template<class T>
        requires requires { typename T::Type; }
    struct ValueType<T>
    {
        using Type = ValueType<typename T::Type>::Type;
    };
 
    template<class T>
    using Value = typename ValueType<T>::Type;
}
#endif // pRC_CORE_VALUE_VALUE_H