types.h

Go to the documentation of this file.

#ifndef TYPES_H
#define TYPES_H
 
#include <type_traits>
#include <concepts>
#include <iosfwd>
#include <functional>
#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 EnumClassType = std::is_enum_v<TYPE> && !std::is_convertible_v<TYPE, std::underlying_type_t<TYPE>>;
 
    // ==================== Comparison Concepts ====================
 
    template <typename T>
    concept EqualityComparable = requires(const T& a, const T& b) {
        { a == b } -> std::convertible_to<bool>;
        { a != b } -> std::convertible_to<bool>;
    };
 
    template <typename T>
    concept WeaklyOrdered = requires(const T& a, const T& b) {
        { a < b } -> std::convertible_to<bool>;
        { a <= b } -> std::convertible_to<bool>;
        { a > b } -> std::convertible_to<bool>;
        { a >= b } -> std::convertible_to<bool>;
    };
 
    template <typename T>
    concept PartiallyComparable = EqualityComparable<T> || WeaklyOrdered<T>;
 
    template <typename T>
    concept TotallyComparable = EqualityComparable<T> && WeaklyOrdered<T>;
 
    template <typename T>
    concept ThreeWayComparable = requires(const T& a, const T& b) {
        { a <=> b } -> std::convertible_to<std::partial_ordering>;
    };
 
    template <typename T>
    concept StronglyOrdered = requires(const T& a, const T& b) {
        { a <=> b } -> std::convertible_to<std::strong_ordering>;
    };
 
    // Alias of TotallyComparable
    template <typename T>
    concept Comparable = TotallyComparable<T>;
 
    template <typename T>
    concept CmpTraits = requires(const T& a, const T& b) {
        { a.compareTo(b) } -> std::same_as<integer>;
    };
 
    // ==================== Stream Concepts ====================
 
    template <typename TYPE>
    concept Printable = requires(std::ostream& os, const TYPE& t) {
        { os << t } -> std::same_as<std::ostream&>;
    };
 
    template <typename TYPE>
    concept InputStreamable = requires(std::istream& is, TYPE& t) {
        { is >> t } -> std::same_as<std::istream&>;
    };
 
    template <typename TYPE>
    concept Streamable = Printable<TYPE> && InputStreamable<TYPE>;
 
    // ==================== Hash Concepts ====================
 
    template <typename T>
    concept Hashable =
        requires(const T& obj) {
            { std::hash<T>{}(obj) } -> std::convertible_to<std::size_t>;
        };
 
    template <typename T>
    concept Equatable =
        requires(const T& a, const T& b) {
            { a == b } -> std::convertible_to<bool>;
        } ||
        requires(const T& a, const T& b) {
            { a.equals(b) } -> std::convertible_to<bool>;
        };
 
    template <typename T>
    concept HashTraits =
        requires(const T& t) {
        { t.toHash() } -> std::same_as<u_integer>;
    } && Equatable<T>;
 
    // ==================== Callback Concepts ====================
 
    template <typename F, typename... Args>
    concept Callable = requires(F&& f, Args&&... args) {
        std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    };
 
    template <typename Callback, typename ReturnType, typename... Args>
    concept CallbackOf = requires(Callback callback, Args&&... args) {
        { callback(std::forward<Args>(args)...) } -> std::convertible_to<ReturnType>;
    };
 
    template <typename Callback, typename... Args>
    concept Predicate = CallbackOf<Callback, bool, Args...>;
 
    template <typename Callback, typename TYPE>
    concept Compare = Predicate<Callback, const TYPE&, const TYPE&>;
 
    template <typename Callback, typename TYPE>
    concept Condition = Predicate<Callback, const TYPE&>;
 
    template <typename Callback, typename TYPE>
    concept Operation = CallbackOf<Callback, void, TYPE&>;
 
    template <typename Callback, typename Input, typename Output>
    concept Transformer = CallbackOf<Callback, Output, Input>;
 
    // ==================== 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>;
 
    template <typename From, typename To>
    concept ConvertibleTo = std::is_convertible_v<From, To>;
 
    template <typename T, typename U>
    concept SameAs = std::is_same_v<T, U>;
 
    // ==================== Container Concepts ====================
 
    template <typename C>
    concept Container = requires(C& c) {
        { c.begin() } -> std::input_or_output_iterator;
        { c.end() } -> std::input_or_output_iterator;
        { c.size() } -> std::convertible_to<std::size_t>;
    };
 
    template <typename C>
    concept SequenceContainer = Container<C> && requires(C& c, typename C::value_type v) {
        c.push_back(v);
        c.pop_back();
    };
 
    // ==================== 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