SdlClass.h

Go to the documentation of this file.

#pragma once
 
#include "SDL/Introspect/ISdlInstantiable.h"
#include "SDL/sdl_fwd.h"
#include "SDL/SdlInputClauses.h"
#include "SDL/SdlOutputClauses.h"
#include "SDL/ESdlTypeCategory.h"
 
#include <Common/primitive_type.h>
#include <Common/logging.h>
 
#include <vector>
#include <cstddef>
#include <string>
#include <string_view>
#include <type_traits>
#include <memory>
 
namespace ph
{
 
PH_DEFINE_EXTERNAL_LOG_GROUP(SdlClass, SDL);
 
class SdlClass : public ISdlInstantiable
{
public:
    SdlClass(ESdlTypeCategory category, const std::string& typeName);
 
    virtual std::shared_ptr<ISdlResource> createResource() const = 0;
 
    virtual void initResource(
        ISdlResource&          resource,
        SdlInputClauses&       clauses,
        const SdlInputContext& ctx) const = 0;
 
    virtual void initDefaultResource(ISdlResource& resource) const = 0;
 
    virtual void saveResource(
        const ISdlResource&     resource,
        SdlOutputClauses&       clauses,
        const SdlOutputContext& ctx) const = 0;
 
    virtual void call(
        std::string_view       funcName,
        ISdlResource*          resource,
        SdlInputClauses&       clauses,
        const SdlInputContext& ctx) const = 0;
 
    virtual void referencedResources(
        const ISdlResource* targetResource,
        std::vector<const ISdlResource*>& out_resources) const = 0;
 
    virtual std::size_t numFunctions() const = 0;
 
    virtual const SdlFunction* getFunction(std::size_t index) const = 0;
 
    std::size_t numFields() const override = 0;
 
    const SdlField* getField(std::size_t index) const override = 0;
 
    std::string_view getTypeName() const override;
    std::string_view getDescription() const override;
 
    bool isBlueprint() const;
 
    bool allowCreateFromClass() const;
 
    std::string genPrettyName() const;
    std::string genCategoryName() const;
    ESdlTypeCategory getCategory() const;
    
    std::string_view getDocName() const;
    const SdlClass* getBase() const;
    bool isDerived() const;
    bool hasField() const;
    bool hasFunction() const;
 
protected:
    SdlClass& setDescription(std::string description);
 
    SdlClass& setDocName(std::string docName);
 
    template<typename SdlResourceType>
    SdlClass& setBase();
 
    SdlClass& setIsBlueprint(bool isBlueprint);
    SdlClass& setAllowCreateFromClass(bool allowCreateFromClass);
 
private:
    ESdlTypeCategory m_category;
    std::string m_typeName;
    std::string m_docName;
    std::string m_description;
    const SdlClass* m_base;
    uint32 m_isBlueprint : 1;
    uint32 m_allowCreateFromClass : 1;
};
 
// In-header Implementation:
 
inline bool SdlClass::isBlueprint() const
{
    return m_isBlueprint;
}
 
inline bool SdlClass::allowCreateFromClass() const
{
    return m_allowCreateFromClass;
}
 
inline ESdlTypeCategory SdlClass::getCategory() const
{
    return m_category;
}
 
inline std::string_view SdlClass::getTypeName() const
{
    return m_typeName;
}
 
inline std::string_view SdlClass::getDocName() const
{
    return m_docName;
}
 
inline std::string_view SdlClass::getDescription() const
{
    return m_description;
}
 
inline const SdlClass* SdlClass::getBase() const
{
    return m_base;
}
 
inline bool SdlClass::isDerived() const
{
    return getBase() != nullptr;
}
 
inline bool SdlClass::hasField() const
{
    return numFields() != 0;
}
 
inline bool SdlClass::hasFunction() const
{
    return numFunctions() != 0;
}
 
template<typename SdlResourceType>
inline SdlClass& SdlClass::setBase()
{
    static_assert(std::is_base_of_v<ISdlResource, SdlResourceType>,
        "Input type must be a SDL resource.");
 
    m_base = SdlResourceType::getSdlClass();
    return *this;
}
 
}// end namespace ph