TypeInfo.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "TypeName.hpp"
#include "IReflectable.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
namespace CeresEngine {
 
    using TypeIdentityHash = UInt64;
    
    template<typename T> consteval TypeIdentityHash getIdentityHash() noexcept {
        return staticHash64(CeresEngine::getTypeName<T>());
    }
    
    enum class TypeAttribute {
        NONE,
        LREF,
        RREF,
        LREF_CONST
    };
 
    class TypeInfo {
    public:
        virtual ~TypeInfo() = default;
 
    public:
        [[nodiscard]] virtual StringView getName() const noexcept = 0;
 
        [[nodiscard]] TypeID getID() const noexcept { return TypeID(reinterpret_cast<UInt64>(this)); }
 
        [[nodiscard]] virtual TypeIdentityHash getIdentityHash() const noexcept = 0;
 
    public:
        [[nodiscard]] virtual const TypeInfo& desugar() const { return *this; }
 
        [[nodiscard]] virtual std::size_t getSize() const noexcept = 0;
 
        [[nodiscard]] virtual std::size_t getAlignment() const noexcept = 0;
 
        template<typename T> [[nodiscard]] bool is() const noexcept { return dynamic_cast<const T*>(this) != nullptr; }
        template<typename T> [[nodiscard]] const T* as() const noexcept { return dynamic_cast<const T*>(this); }
        template<typename T> [[nodiscard]] const T* being() const noexcept { return dynamic_cast<const T*>(this); }
 
    public:
        [[nodiscard]] const TypeInfo& removeReference() const;
        [[nodiscard]] const TypeInfo& removePointer() const;
        [[nodiscard]] const TypeInfo& removeConst() const;
 
    public: // Construction, copy & move
        [[nodiscard]] virtual const TypeInfo& getType(TypeAttribute attribute) const = 0;
 
        [[nodiscard]] virtual const void* access(const void* target) const { return target; }
    };
 
    class ConstructibleTypeTrait {
    protected:
        ~ConstructibleTypeTrait() = default;
 
    public:
        virtual void construct(void* target) const = 0;
    };
 
    class DestructibleTypeTrait {
    protected:
        ~DestructibleTypeTrait() = default;
 
    public:
        virtual void destroy(void* target) const = 0;
    };
 
    class CopyableTypeTrait {
    protected:
        ~CopyableTypeTrait() = default;
 
    public:
        virtual void copy(void* target, const void* source) const = 0;
    };
 
    class MovableTypeTrait {
    protected:
        ~MovableTypeTrait() = default;
 
    public:
        virtual void move(void* target, void* source) const = 0;
    };
 
    class DereferenceableTypeTrait {
    protected:
        ~DereferenceableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual Box dereference(const Box& value) const = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct HashableTypeTrait {
    protected:
        ~HashableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual size_t hash(const Box& object) const = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class EqualityComparableTypeTrait {
    protected:
        ~EqualityComparableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual bool equals(const Box& lhs, const Box& rhs) const = 0;
 
        [[nodiscard]] virtual bool notEquals(const Box& lhs, const Box& rhs) const {
            return !equals(lhs, rhs);
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class TotallyOrderedTypeTrait {
    protected:
        ~TotallyOrderedTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual bool greaterThan(const Box& lhs, const Box& rhs) const = 0;
        [[nodiscard]] virtual bool greaterThanOrEquals(const Box& lhs, const Box& rhs) const = 0;
        [[nodiscard]] virtual bool lessThan(const Box& lhs, const Box& rhs) const = 0;
        [[nodiscard]] virtual bool lessThanOrEquals(const Box& lhs, const Box& rhs) const = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class IncrementableTypeTrait {
    protected:
        ~IncrementableTypeTrait() = default;
 
    public:
        virtual void increment(const Box& value) const = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class IterableTypeTrait {
    protected:
        ~IterableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual Box begin(const Box& value) const = 0;
 
        [[nodiscard]] virtual Box end(const Box& value) const = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class IndexableTypeTrait {
        protected:
        ~IndexableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual Box get(const Box& target, size_t index) const = 0;
 
        virtual void set(const Box& target, size_t index, Box&& value) const = 0;
    };
 
    struct InsertableTypeTrait {
    protected:
        ~InsertableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual Box insert(const Box& container, const Box& where, Box&& value) const = 0;
    };
 
    struct ErasableTypeTrait {
    protected:
        ~ErasableTypeTrait() = default;
 
    public:
        [[nodiscard]] virtual Box erase(const Box& container, const Box& where) const = 0;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    class PushBackableTypeTrait {
    protected:
        ~PushBackableTypeTrait() = default;
 
    public:
        virtual void pushBack(const Box& container, Box&& value) const = 0;
    };
 
} // namespace CeresEngine