NamedType.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace CeresEngine {
 
    template<typename T> using IsNotReference = typename std::enable_if<!std::is_reference<T>::value, void>::type;
 
    template<typename T, template<typename> class CRTPType> struct CRTP {
        constexpr T& getUnderlying() { return static_cast<T&>(*this); }
        constexpr T const& getUnderlying() const { return static_cast<T const&>(*this); }
    };
 
    template<typename T, typename Parameter, template<typename> class... Skills> class NamedType : public Skills<NamedType<T, Parameter, Skills...>>... {
    public:
        using UnderlyingType = T;
        using ReferenceType = NamedType<T&, Parameter, Skills...>;
 
        T raw;
 
        // constructor
        NamedType() = default;
 
        explicit constexpr NamedType(T const& value) noexcept(std::is_nothrow_copy_constructible<T>::value) : raw(value) {}
 
        template<typename TType = T, typename = IsNotReference<TType>>
        explicit constexpr NamedType(T&& value) noexcept(std::is_nothrow_move_constructible<T>::value) : raw(std::move(value)) {}
 
        // get
        [[nodiscard]] constexpr T& get() noexcept { return raw; }
        [[nodiscard]] constexpr std::remove_reference_t<T> const& get() const noexcept { return raw; }
 
        // conversions
        operator ReferenceType() { return ReferenceType(raw); }
    };
 
    template<template<typename T> class StrongType, typename T> constexpr StrongType<T> make_named(T const& value) { return StrongType<T>(value); }
 
    namespace details {
        template<class F, class... Ts> struct AnyOrderCallable {
            F f;
            template<class... Us> auto operator()(Us&&... args) const {
                static_assert(sizeof...(Ts) == sizeof...(Us), "Passing wrong number of arguments");
                auto x = std::make_tuple(std::forward<Us>(args)...);
                return f(std::move(std::get<Ts>(x))...);
            }
        };
    } //namespace details
 
    template<typename T> struct PreIncrementable : CRTP<T, PreIncrementable> {
        constexpr T& operator++() {
            ++this->getUnderlying().get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct PostIncrementable : CRTP<T, PostIncrementable> {
        constexpr T operator++(int) { return T(this->getUnderlying().get()++); }
    };
 
    template<typename T> struct PreDecrementable : CRTP<T, PreDecrementable> {
        constexpr T& operator--() {
            --this->getUnderlying().get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct PostDecrementable : CRTP<T, PostDecrementable> {
        constexpr T operator--(int) { return T(this->getUnderlying().get()--); }
    };
 
    template<typename T> struct BinaryAddable : CRTP<T, BinaryAddable> {
        [[nodiscard]] constexpr T operator+(T const& other) const { return T(this->getUnderlying().get() + other.get()); }
        constexpr T& operator+=(T const& other) {
            this->getUnderlying().get() += other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct UnaryAddable : CRTP<T, UnaryAddable> {
        [[nodiscard]] constexpr T operator+() const { return T(+this->getUnderlying().get()); }
    };
 
    template<typename T> struct Addable : BinaryAddable<T>, UnaryAddable<T> {
        using BinaryAddable<T>::operator+;
        using UnaryAddable<T>::operator+;
    };
 
    template<typename T> struct BinarySubtractable : CRTP<T, BinarySubtractable> {
        [[nodiscard]] constexpr T operator-(T const& other) const { return T(this->getUnderlying().get() - other.get()); }
        constexpr T& operator-=(T const& other) {
            this->getUnderlying().get() -= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct UnarySubtractable : CRTP<T, UnarySubtractable> {
        [[nodiscard]] constexpr T operator-() const { return T(-this->getUnderlying().get()); }
    };
 
    template<typename T> struct Subtractable : BinarySubtractable<T>, UnarySubtractable<T> {
        using UnarySubtractable<T>::operator-;
        using BinarySubtractable<T>::operator-;
    };
 
    template<typename T> struct Multiplicable : CRTP<T, Multiplicable> {
        [[nodiscard]] constexpr T operator*(T const& other) const { return T(this->getUnderlying().get() * other.get()); }
        constexpr T& operator*=(T const& other) {
            this->getUnderlying().get() *= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct Divisible : CRTP<T, Divisible> {
        [[nodiscard]] constexpr T operator/(T const& other) const { return T(this->getUnderlying().get() / other.get()); }
        constexpr T& operator/=(T const& other) {
            this->getUnderlying().get() /= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct Modulable : CRTP<T, Modulable> {
        [[nodiscard]] constexpr T operator%(T const& other) const { return T(this->getUnderlying().get() % other.get()); }
        constexpr T& operator%=(T const& other) {
            this->getUnderlying().get() %= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct BitwiseInvertable : CRTP<T, BitwiseInvertable> {
        [[nodiscard]] constexpr T operator~() const { return T(~this->getUnderlying().get()); }
    };
 
    template<typename T> struct BitwiseAndable : CRTP<T, BitwiseAndable> {
        [[nodiscard]] constexpr T operator&(T const& other) const { return T(this->getUnderlying().get() & other.get()); }
        constexpr T& operator&=(T const& other) {
            this->getUnderlying().get() &= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct BitwiseOrable : CRTP<T, BitwiseOrable> {
        [[nodiscard]] constexpr T operator|(T const& other) const { return T(this->getUnderlying().get() | other.get()); }
        constexpr T& operator|=(T const& other) {
            this->getUnderlying().get() |= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct BitwiseXorable : CRTP<T, BitwiseXorable> {
        [[nodiscard]] constexpr T operator^(T const& other) const { return T(this->getUnderlying().get() ^ other.get()); }
        constexpr T& operator^=(T const& other) {
            this->getUnderlying().get() ^= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct BitwiseLeftShiftable : CRTP<T, BitwiseLeftShiftable> {
        [[nodiscard]] constexpr T operator<<(T const& other) const { return T(this->getUnderlying().get() << other.get()); }
        constexpr T& operator<<=(T const& other) {
            this->getUnderlying().get() <<= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct BitwiseRightShiftable : CRTP<T, BitwiseRightShiftable> {
        [[nodiscard]] constexpr T operator>>(T const& other) const { return T(this->getUnderlying().get() >> other.get()); }
        constexpr T& operator>>=(T const& other) {
            this->getUnderlying().get() >>= other.get();
            return this->getUnderlying();
        }
    };
 
    template<typename T> struct ComparableTrait : CRTP<T, ComparableTrait> {
        [[nodiscard]] constexpr bool operator<(ComparableTrait<T> const& other) const { return this->getUnderlying().get() < other.getUnderlying().get(); }
        [[nodiscard]] constexpr bool operator>(ComparableTrait<T> const& other) const { return other.getUnderlying().get() < this->getUnderlying().get(); }
        [[nodiscard]] constexpr bool operator<=(ComparableTrait<T> const& other) const { return !(other < *this); }
        [[nodiscard]] constexpr bool operator>=(ComparableTrait<T> const& other) const { return !(*this < other); }
        [[nodiscard]] constexpr bool operator==(ComparableTrait<T> const& other) const { return !(*this < other) && !(other < *this); }
        [[nodiscard]] constexpr bool operator!=(ComparableTrait<T> const& other) const { return !(*this == other); }
    };
 
    template<typename T> struct Dereferencable;
 
    template<typename T, typename Parameter, template<typename> class... Skills>
    struct Dereferencable<NamedType<T, Parameter, Skills...>> : CRTP<NamedType<T, Parameter, Skills...>, Dereferencable> {
        [[nodiscard]] constexpr T& operator*() & { return this->getUnderlying().get(); }
        [[nodiscard]] constexpr std::remove_reference_t<T> const& operator*() const& { return this->getUnderlying().get(); }
    };
 
    template<typename Destination> struct ImplicitlyConvertibleTo {
        template<typename T> struct templ : CRTP<T, templ> {
            [[nodiscard]] constexpr operator Destination() const { return this->getUnderlying().get(); }
        };
    };
 
    template<typename T> struct Printable : CRTP<T, Printable> {
        static constexpr bool is_printable = true;
 
        void print(std::ostream& os) const { os << this->getUnderlying().get(); }
    };
 
    template<typename T, typename Parameter, template<typename> class... Skills>
    typename std::enable_if<NamedType<T, Parameter, Skills...>::is_printable, std::ostream&>::type operator<<(std::ostream& os,
        NamedType<T, Parameter, Skills...> const& object) {
        object.print(os);
        return os;
    }
 
    template<typename T> struct HashableTrait { static constexpr bool is_hashable = true; };
 
    template<typename NamedType_> struct FunctionCallable;
 
    template<typename T, typename Parameter, template<typename> class... Skills>
    struct FunctionCallable<NamedType<T, Parameter, Skills...>> : CRTP<NamedType<T, Parameter, Skills...>, FunctionCallable> {
        [[nodiscard]] constexpr operator T const&() const { return this->getUnderlying().get(); }
        [[nodiscard]] constexpr operator T&() { return this->getUnderlying().get(); }
    };
 
    template<typename NamedType_> struct MethodCallable;
 
    template<typename T, typename Parameter, template<typename> class... Skills>
    struct MethodCallable<NamedType<T, Parameter, Skills...>> : CRTP<NamedType<T, Parameter, Skills...>, MethodCallable> {
        [[nodiscard]] constexpr std::remove_reference_t<T> const* operator->() const { return std::addressof(this->getUnderlying().get()); }
        [[nodiscard]] constexpr std::remove_reference_t<T>* operator->() { return std::addressof(this->getUnderlying().get()); }
    };
 
    template<typename NamedType_> struct Callable : FunctionCallable<NamedType_>, MethodCallable<NamedType_> {};
 
    template<typename T> struct Incrementable : PreIncrementable<T>, PostIncrementable<T> {
        using PostIncrementable<T>::operator++;
        using PreIncrementable<T>::operator++;
    };
 
    template<typename T> struct Decrementable : PreDecrementable<T>, PostDecrementable<T> {
        using PostDecrementable<T>::operator--;
        using PreDecrementable<T>::operator--;
    };
 
    template<typename T>
    struct Arithmetic : Incrementable<T>,
                        Decrementable<T>,
                        Addable<T>,
                        Subtractable<T>,
                        Multiplicable<T>,
                        Divisible<T>,
                        Modulable<T>,
                        BitwiseInvertable<T>,
                        BitwiseAndable<T>,
                        BitwiseOrable<T>,
                        BitwiseXorable<T>,
                        BitwiseLeftShiftable<T>,
                        BitwiseRightShiftable<T>,
                        ComparableTrait<T>,
                        Printable<T>,
                        HashableTrait<T> {};
 
} // namespace CeresEngine
 
template<typename T, typename Parameter, template<typename> class... Skills> struct std::hash<CeresEngine::NamedType<T, Parameter, Skills...>> {
    using NamedType = CeresEngine::NamedType<T, Parameter, Skills...>;
    using checkIfHashable = typename std::enable_if<NamedType::is_hashable, void>::type;
 
    size_t operator()(CeresEngine::NamedType<T, Parameter, Skills...> const& x) const noexcept {
        static_assert(noexcept(std::hash<T>()(x.get())), "hash fuction should not throw");
 
        return std::hash<T>()(x.get());
    }
};