TypeInfo.std.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 "TypeInfo.core.hpp"
#include "TypeInfo.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/List.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine {
 
    template<typename T> class SmartPointerTypeInfo : public TTypeInfo<T, impl::TDereferenceableTypeTrait> {
        using super = TypeInfo;
 
    public:
        using PointerType = T;
        using ElementType = std::remove_cvref_t<decltype(*std::declval<PointerType>())>;
 
    public:
        [[nodiscard]] StringView getName() const noexcept override { return "SPtr"; }
    };
 
    template<typename T> struct GetTypeInfo<SPtr<T>> {
        static const TypeInfo& get() {
            static const SmartPointerTypeInfo<SPtr<T>> type;
            return type;
        }
    };
 
    template<typename T, typename Deleter> struct GetTypeInfo<UPtr<T, Deleter>> {
        static const TypeInfo& get() {
            static const SmartPointerTypeInfo<UPtr<T, Deleter>> type;
            return type;
        }
    };
 
    template<typename T> struct GetTypeInfo<RC<T>> {
        static const TypeInfo& get() {
            static const SmartPointerTypeInfo<RC<T>> type;
            return type;
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T>
    class TContainerTypeInfo : public TTypeInfoBase<T, //
                                   impl::TConstructibleTypeTrait, //
                                   impl::TDestructibleTypeTrait, //
                                   impl::TCopyableTypeTrait, //
                                   impl::TMovableTypeTrait, //
                                   impl::TIterableTypeTrait, //
                                   impl::TPushBackableTypeTrait, //
                                   impl::TIndexableTypeTrait, //
                                   impl::TInsertableTypeTrait, //
                                   impl::TErasableTypeTrait //
                                   > {
        using super = TypeInfo;
 
    public:
        using VectorType = T;
        using ElementType = typename VectorType::value_type;
 
    public:
        [[nodiscard]] StringView getName() const noexcept override { return "Vector"; }
    };
 
    template<typename T, typename Allocator> struct GetTypeInfo<Vector<T, Allocator>> {
        static const TypeInfo& get() {
            static const TContainerTypeInfo<Vector<T, Allocator>> type;
            return type;
        }
    };
 
    template<typename T, size_t N, typename Allocator> struct GetTypeInfo<SmallVector<T, N, Allocator>> {
        static const TypeInfo& get() {
            static const TContainerTypeInfo<SmallVector<T, N, Allocator>> type;
            return type;
        }
    };
 
    template<typename T, size_t N> struct GetTypeInfo<Array<T, N>> {
        static const TypeInfo& get() {
            static const TContainerTypeInfo<Array<T, N>> type;
            return type;
        }
    };
 
    template<typename T, typename Allocator> struct GetTypeInfo<List<T, Allocator>> {
        static const TypeInfo& get() {
            static const TContainerTypeInfo<List<T, Allocator>> type;
            return type;
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, typename> class TIteratorTypeInfo;
 
    template<typename T>
    class TIteratorTypeInfo<T, std::input_iterator_tag> : public TTypeInfo<T, impl::TDereferenceableTypeTrait, impl::TIncrementableTypeTrait> {
    public:
        [[nodiscard]] StringView getName() const noexcept override { return getTypeName<T>(); }
    };
 
    template<typename T> requires std::input_iterator<T>
    struct GetTypeInfo<T> {
        static const TypeInfo& get() {
            static const TIteratorTypeInfo<T, std::input_iterator_tag> type;
            return type;
        }
    };
 
} // namespace CeresEngine