types.h

Go to the documentation of this file.

#ifndef TYPES_H
#define TYPES_H
 
#include <type_traits>
#include <concepts>
#include <iosfwd>
#include "config.h"
 
namespace original {
 
    // ==================== Fundamental Types ====================
 
    class none {
    public:
        consteval explicit none() = default;
 
        constexpr ~none() = default;
 
        consteval explicit operator bool() const;
 
        consteval bool operator!() const;
    };
 
    // ==================== Core Concepts ====================
 
    template<typename... ARGS>
    concept NotNull = sizeof...(ARGS) > 0;
 
    template<typename TYPE>
    concept EnumType = std::is_enum_v<TYPE>;
 
    template <typename TYPE>
    concept Comparable = requires(const TYPE& t1, const TYPE& t2) {
        { t1 == t2 } -> std::same_as<bool>;
        { t1 != t2 } -> std::same_as<bool>;
        { t1 < t2 } -> std::same_as<bool>;
        { t1 <= t2 } -> std::same_as<bool>;
        { t1 > t2 } -> std::same_as<bool>;
        { t1 >= t2 } -> std::same_as<bool>;
    };
 
    template <typename TYPE>
    concept Printable = requires(std::ostream& os, const TYPE& t) {
        { os << t } -> std::same_as<std::ostream&>;
    };
 
    // ==================== Callback Concepts ====================
 
    template <typename Callback, typename ReturnType, typename... Args>
    concept CallbackOf = requires(Callback callback, Args&&... args) {
        { callback(std::forward<Args>(args)...) } -> std::same_as<ReturnType>;
    };
 
    template <typename Callback, typename TYPE>
    concept Compare = Comparable<TYPE> &&
                     CallbackOf<Callback, bool, const TYPE&, const TYPE&>;
 
    template <typename Callback, typename TYPE>
    concept Condition = CallbackOf<Callback, bool, const TYPE&>;
 
    template <typename Callback, typename TYPE>
    concept Operation = CallbackOf<Callback, void, TYPE&>;
 
    // ==================== Type Relationship Concepts ====================
 
    template <typename Base, typename Derive>
    concept SuperOf = std::is_base_of_v<Base, Derive> || std::is_same_v<Base, Derive>;
 
    template <typename Base, typename Derive>
    concept ExtendsOf = std::derived_from<Derive, Base> || std::is_same_v<Base, Derive>;
 
    // ==================== Compile-time Index Sequences ====================
 
    template <u_integer... INTS>
    class indexSequence {
        static constexpr u_integer SIZE = sizeof...(INTS);
    public:
        static consteval u_integer size() noexcept;
    };
 
    class makeIndexSequence {
        template <u_integer NUM, u_integer... INTS>
        class indexSequenceImpl;
 
        template <u_integer... INTS>
        class indexSequenceImpl<0, INTS...> {
        public:
            using type = indexSequence<INTS...>;
        };
 
        template <u_integer NUM, u_integer... INTS>
        class indexSequenceImpl : public indexSequenceImpl<NUM - 1, NUM - 1, INTS...> {
        public:
            using type = indexSequenceImpl<NUM - 1, NUM - 1, INTS...>::type;
        };
    public:
        template <u_integer NUM>
        friend consteval auto makeSequence() noexcept;
    };
 
    template <u_integer NUM>
    consteval auto makeSequence() noexcept; // NOLINT: Forward declaration for makeReverseSequence
 
    template<u_integer... Indices>
    consteval auto reverseIndexSequenceImpl(indexSequence<Indices...> seq);
 
    template<u_integer N>
    using makeReverseSequence = decltype(
        reverseIndexSequenceImpl(makeSequence<N>())
    );
 
    // ==================== Function Traits ====================
 
    template <typename Callback>
    struct functionTraits;
 
    template <typename R, typename... Args>
    struct functionTraits<R(*)(Args...)> {
        using ReturnType = R;
        using Signature = R(Args...);
    };
 
    template <typename R, typename... Args>
    struct functionTraits<R(Args...)> {
        using ReturnType = R;
        using Signature = R(Args...);
    };
 
    template <typename C>
    struct functionTraits {
    private:
        using CallType = functionTraits<decltype(&C::operator())>;
    public:
        using ReturnType = CallType::ReturnType;
        using Signature  = CallType::Signature;
    };
 
    template <typename C, typename R, typename... Args>
    struct functionTraits<R(C::*)(Args...) const> {
        using ReturnType = R;
        using Signature  = R(Args...);
    };
 
    template <typename C, typename R, typename... Args>
    struct functionTraits<R(C::*)(Args...)> {
        using ReturnType = R;
        using Signature  = R(Args...);
    };
 
} // namespace original
 
consteval original::none::operator bool() const {
    return false;
}
 
consteval bool original::none::operator!() const {
    return true;
}
 
template<original::u_integer... INTS>
consteval original::u_integer original::indexSequence<INTS...>::size() noexcept {
    return SIZE;
}
 
template<original::u_integer NUM>
consteval auto original::makeSequence() noexcept {
    using sequence = makeIndexSequence::indexSequenceImpl<NUM>::type;
    return sequence{};
}
 
template <original::u_integer... Indices>
consteval auto original::reverseIndexSequenceImpl(indexSequence<Indices...>)
{
    return indexSequence<sizeof...(Indices) - 1 - Indices...>{};
}
 
#endif // TYPES_H