Namespace.h

 
#pragma once
 
#include "Refureku/TypeInfo/Entity/Entity.h"
#include "Refureku/TypeInfo/Variables/EVarFlags.h"
#include "Refureku/TypeInfo/Functions/EFunctionFlags.h"
#include "Refureku/TypeInfo/Functions/FunctionHelper.h"
 
namespace rfk
{
    //Forward declarations
    class Struct;
    using Class = Struct;
    class Enum;
    class Variable;
    class Function;
    class Archetype;
 
    class Namespace final : public Entity
    {
        public:
            REFUREKU_INTERNAL Namespace(char const* name,
                                        std::size_t id)     noexcept;
            Namespace(Namespace&&)                          = delete;
            REFUREKU_INTERNAL ~Namespace()                  noexcept;
 
            RFK_NODISCARD REFUREKU_API Namespace const*             getNamespaceByName(char const* name)                                const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Namespace const*             getNamespaceByPredicate(Predicate<Namespace>    predicate,
                                                                                            void*                   userData)           const;
 
            RFK_NODISCARD REFUREKU_API Vector<Namespace const*>     getNamespacesByPredicate(Predicate<Namespace>   predicate,
                                                                                             void*                  userData)           const;
 
            REFUREKU_API bool                                       foreachNamespace(Visitor<Namespace> visitor,
                                                                                     void*              userData)                       const;
 
            REFUREKU_API std::size_t                                getNamespacesCount()                                                const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Struct const*                getStructByName(char const* name)                                   const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Struct const*                getStructByPredicate(Predicate<Struct>  predicate,
                                                                                         void*              userData)                   const;
 
            RFK_NODISCARD REFUREKU_API Vector<Struct const*>        getStructsByPredicate(Predicate<Struct> predicate,
                                                                                          void*             userData)                   const;
 
            REFUREKU_API bool                                       foreachStruct(Visitor<Struct>   visitor,
                                                                                  void*             userData)                           const;
 
            RFK_NODISCARD REFUREKU_API Class const*                 getClassByName(char const* name)                                    const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Class const*                 getClassByPredicate(Predicate<Class>    predicate,
                                                                                        void*               userData)                   const;
 
            RFK_NODISCARD REFUREKU_API Vector<Class const*>         getClassesByPredicate(Predicate<Class>  predicate,
                                                                                          void*             userData)                   const;
 
            REFUREKU_API bool                                       foreachClass(Visitor<Class> visitor,
                                                                                  void*         userData)                               const;
 
            RFK_NODISCARD REFUREKU_API Enum const*                  getEnumByName(char const* name)                                     const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Enum const*                  getEnumByPredicate(Predicate<Enum>  predicate,
                                                                                       void*            userData)                       const;
 
            RFK_NODISCARD REFUREKU_API Vector<Enum const*>          getEnumsByPredicate(Predicate<Enum> predicate,
                                                                                        void*           userData)                       const;
 
            REFUREKU_API bool                                       foreachEnum(Visitor<Enum>   visitor,
                                                                                 void*          userData)                               const;
 
            REFUREKU_API bool                                       foreachArchetype(Visitor<Archetype> visitor,
                                                                                     void*              userData)                       const;
 
            REFUREKU_API std::size_t                                getArchetypesCount()                                                const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Variable const*              getVariableByName(char const*   name,
                                                                                      EVarFlags     flags = EVarFlags::Default)         const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Variable const*              getVariableByPredicate(Predicate<Variable>  predicate,
                                                                                           void*                userData)               const;
 
            RFK_NODISCARD REFUREKU_API Vector<Variable const*>      getVariablesByPredicate(Predicate<Variable> predicate,
                                                                                            void*               userData)               const;
 
            REFUREKU_API bool                                       foreachVariable(Visitor<Variable>   visitor,
                                                                                    void*               userData)                       const;
 
            REFUREKU_API std::size_t                                getVariablesCount()                                                 const   noexcept;
 
            template <typename FunctionSignature>
            RFK_NODISCARD Function const*                           getFunctionByName(char const*    name,
                                                                                      EFunctionFlags flags = EFunctionFlags::Default)   const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Function const*              getFunctionByName(char const*    name,
                                                                                      EFunctionFlags flags = EFunctionFlags::Default)   const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Vector<Function const*>      getFunctionsByName(char const*    name,
                                                                                       EFunctionFlags flags = EFunctionFlags::Default)  const   noexcept;
 
            RFK_NODISCARD REFUREKU_API Function const*              getFunctionByPredicate(Predicate<Function>  predicate,
                                                                                           void*                userData)               const;
 
            RFK_NODISCARD REFUREKU_API Vector<Function const*>      getFunctionsByPredicate(Predicate<Function> predicate,
                                                                                            void*               userData)               const;
 
            REFUREKU_API bool                                       foreachFunction(Visitor<Function>   visitor,
                                                                                    void*               userData)                       const;
 
            REFUREKU_API std::size_t                                getFunctionsCount()                                                 const   noexcept;
 
            REFUREKU_API void                                       addNamespace(Namespace const& nestedNamespace)                              noexcept;
 
            REFUREKU_API void                                       addArchetype(Archetype const& archetype)                                    noexcept;
 
            REFUREKU_API void                                       addVariable(Variable const& variable)                                       noexcept;
 
            REFUREKU_API void                                       addFunction(Function const& function)                                       noexcept;
 
            REFUREKU_API void                                       removeNamespace(Namespace const& nestedNamespace)                           noexcept;
 
            REFUREKU_API void                                       removeArchetype(Archetype const& archetype)                                 noexcept;
 
            REFUREKU_API void                                       removeVariable(Variable const& variable)                                    noexcept;
 
            REFUREKU_API void                                       removeFunction(Function const& function)                                    noexcept;
 
        private:
            //Forward declaration
            class NamespaceImpl;
 
            RFK_GEN_GET_PIMPL(NamespaceImpl, Entity::getPimpl())
    };
 
    REFUREKU_TEMPLATE_API(rfk::Allocator<Namespace const*>);
    REFUREKU_TEMPLATE_API(rfk::Vector<Namespace const*, rfk::Allocator<Namespace const*>>);
 
    #include "Refureku/TypeInfo/Namespace/Namespace.inl"
}