VVMClass.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
 
#include "Containers/StringFwd.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "VerseVM/VVMArray.h"
#include "VerseVM/VVMCppClassInfo.h"
#include "VerseVM/VVMEmergentType.h"
#include "VerseVM/VVMNamedType.h"
#include "VerseVM/VVMProcedure.h"
#include "VerseVM/VVMShape.h"
 
class UObject;
class UVerseClass;
class UVerseStruct;
 
namespace Verse
{
enum class EValueStringFormat;
struct FAbstractVisitor;
struct VObject;
struct VValueObject;
struct VNativeStruct;
struct VProcedure;
struct VPackage;
struct VFunction;
struct VScope;
struct VNativeConstructorWrapper;
struct FInitOrValidateUVerseClass;
struct FInitOrValidateUVerseStruct;
struct FInitOrValidateUStruct;
 
struct FEmergentTypesCacheKeyFuncs : TDefaultMapKeyFuncs<TWriteBarrier<VUniqueStringSet>, TWriteBarrier<VEmergentType>, /*bInAllowDuplicateKeys*/ false>
{
public:
    static bool Matches(KeyInitType A, KeyInitType B);
    static bool Matches(KeyInitType A, const VUniqueStringSet& B);
    static uint32 GetKeyHash(KeyInitType Key);
    static uint32 GetKeyHash(const VUniqueStringSet& Key);
};
 
enum class EArchetypeEntryFlags : uint8
{
    None = 0,
    NativeRepresentation = 1 << 0,
    HasDefaultValueExpression = 1 << 1,
    Instanced = 1 << 2,
    UseCRCName = 1 << 3,
    Predicts = 1 << 4,
    Var = 1 << 5
};
ENUM_CLASS_FLAGS(EArchetypeEntryFlags)
 
 
struct VArchetype : VCell
{
    DECLARE_DERIVED_VCPPCLASSINFO(COREUOBJECT_API, VCell);
    COREUOBJECT_API static TGlobalTrivialEmergentTypePtr<&StaticCppClassInfo> GlobalTrivialEmergentType;
 
    struct VEntry
    {
        static VEntry Constant(FAllocationContext Context, VUniqueString& InQualifiedField, VValue InType, VValue InValue);
        static VEntry Field(FAllocationContext Context, VUniqueString& InQualifiedField, VValue InType);
        static VEntry InitializedField(FAllocationContext Context, VUniqueString& InQualifiedField, VValue InType);
 
        static VEntry ObjectField(FAllocationContext Context, VUniqueString& InQualifiedField);
 
        bool IsConstant() const;
        bool IsNativeRepresentation() const;
        bool UseCRCName() const;
        bool HasDefaultValueExpression() const;
        bool IsInstanced() const;
        bool IsPredicts() const;
        bool IsVar() const;
 
        COREUOBJECT_API bool IsMethod() const;
 
        TWriteBarrier<VUniqueString> Name;
 
        TWriteBarrier<VValue> Type;
 
        /*
          `Value` should be one of the following:
 
          - An uninitialized `VValue`, for a field initializer (regardless of whether or not the field is actually uninitialized).
 
          - A constant `VValue` representing a default field value. (This may be a `VFunction` without the `Self` member
            for methods, since they will bind `Self` lazily).
         */
        TWriteBarrier<VValue> Value;
 
        EArchetypeEntryFlags Flags;
    };
 
    VRestValue Class{0};
 
    VRestValue NextArchetype{0};
 
    uint32 NumEntries;
    VEntry Entries[];
 
    static VArchetype& New(FAllocationContext Context, VValue InNextArchetype, const TArray<VEntry>& InEntries);
 
    COREUOBJECT_API void AppendToStringImpl(FAllocationContext Context, FUtf8StringBuilderBase& Builder, EValueStringFormat Format, TSet<const void*>& VisitedObjects, uint32 RecursionDepth);
 
    static void SerializeLayout(FAllocationContext Context, VArchetype*& This, FStructuredArchiveVisitor& Visitor);
    void SerializeImpl(FAllocationContext Context, FStructuredArchiveVisitor& Visitor);
 
    COREUOBJECT_API VValue LoadFunction(FAllocationContext Context, VUniqueString& FieldName, VValue SelfObject);
 
private:
    static VArchetype& NewUninitialized(FAllocationContext Context, const uint32 InNumEntries)
    {
        size_t NumBytes = offsetof(VArchetype, Entries) + InNumEntries * sizeof(Entries[0]);
        return *new (Context.AllocateFastCell(NumBytes)) VArchetype(Context, InNumEntries);
    }
 
    VArchetype(FAllocationContext Context, VValue InNextArchetype, const TArray<VEntry>& InEntries);
    VArchetype(FAllocationContext Context, const uint32 InNumEntries);
 
    friend struct VClass;
};
 
struct VClass : VNamedType
{
    DECLARE_DERIVED_VCPPCLASSINFO(COREUOBJECT_API, VNamedType);
    COREUOBJECT_API static TGlobalTrivialEmergentTypePtr<&StaticCppClassInfo> GlobalTrivialEmergentType;
 
    enum class EKind : uint8
    {
        Class,
        Struct,
        Interface
    };
    enum class EFlags : uint16
    {
        None = 0,
        NativeRepresentation = 1 << 0,
        NativeStructWithObjectReferences = 1 << 1,
        Concrete = 1 << 2,
        FinalSuper = 1 << 3,
        ExplicitlyCastable = 1 << 4,
        Parametric = 1 << 5,
        UniversallyAccessible = 1 << 6,
        EpicInternal = 1 << 7,
        VNIEpicInternal = 1 << 8,
        Predicts = 1 << 9,
    };
 
    EKind GetKind() const { return Kind; }
    bool IsStruct() const { return GetKind() == EKind::Struct; }
    bool IsInterface() const { return GetKind() == EKind::Interface; }
 
    bool IsNativeRepresentation() const { return EnumHasAllFlags(Flags, EFlags::NativeRepresentation); }
    bool IsNativeStruct() const { return IsNativeRepresentation() && IsStruct(); }
    bool IsNativeStructWithObjectReferences() const { return EnumHasAllFlags(Flags, EFlags::NativeStructWithObjectReferences); }
    bool IsPredicts() const { return EnumHasAllFlags(Flags, EFlags::Predicts); }
 
    TArrayView<TWriteBarrier<VClass>> GetInherited() { return {Inherited, NumInherited}; }
    VArchetype& GetArchetype() const { return *Archetype.Get(); }
    VFunction& GetConstructor() const { return *Constructor.Get(); }
 
    COREUOBJECT_API VValueObject& NewVObject(FAllocationContext Context, VArchetype& InArchetype);
    COREUOBJECT_API VValueObject& NewVObjectOfEmergentType(FAllocationContext Context, VEmergentType& EmergentType);
 
    COREUOBJECT_API VNativeConstructorWrapper& NewNativeStruct(FAllocationContext Context);
 
    template <class CppStructType>
    VNativeStruct& NewNativeStruct(FAllocationContext Context, CppStructType&& Struct);
 
    COREUOBJECT_API VNativeConstructorWrapper& NewUObject(FAllocationContext Context, VArchetype& InArchetype);
 
    VEmergentType& GetOrCreateEmergentTypeForVObject(FAllocationContext Context, VCppClassInfo* CppClassInfo, VArchetype& InArchetype);
    COREUOBJECT_API VEmergentType& GetOrCreateEmergentTypeForNativeStruct(FAllocationContext Context);
    COREUOBJECT_API UStruct* GetOrCreateNativeType(FAllocationContext Context);
 
    static VClass& New(
        FAllocationContext Context,
        VPackage* InPackageScope,
        VArray* InRelativePath,
        VArray* InClassName,
        VArray* InAttributeIndices,
        VArray* InAttributes,
        UStruct* InImportStruct,
        bool bNativeBound,
        EKind InKind,
        EFlags InFlags,
        const TArray<VClass*>& InInherited,
        VArchetype& InArchetype,
        VProcedure& InConstructor);
 
    bool SubsumesImpl(FAllocationContext, VValue);
 
    static void SerializeLayout(FAllocationContext Context, VClass*& This, FStructuredArchiveVisitor& Visitor);
    void SerializeImpl(FAllocationContext Context, FStructuredArchiveVisitor& Visitor);
 
    COREUOBJECT_API TSharedPtr<FJsonValue> ToJSONImpl(FRunningContext Context, EValueJSONFormat Format, TMap<const void*, EVisitState>& VisitedObjects, const VerseVMToJsonCallback& Callback, uint32 RecursionDepth, FJsonObject* Defs);
    COREUOBJECT_API VValue FromJSONImpl(FRunningContext Context, const FJsonValue& JsonValue, EValueJSONFormat Format);
 
private:
    COREUOBJECT_API VClass(
        FAllocationContext Context,
        VPackage* InPackageScope,
        VArray* InRelativePath,
        VArray* InClassName,
        VArray* InAttributeIndices,
        VArray* InAttributes,
        UStruct* InImportStruct,
        bool bInNativeBound,
        EKind InKind,
        EFlags InFlags,
        const TArray<VClass*>& InInherited,
        VArchetype& InArchetype,
        VProcedure& InConstructor);
 
    COREUOBJECT_API VClass(FAllocationContext Context, int32 NumInherited);
 
    static void WalkArchetypeFields(
        FAllocationContext Context,
        VArchetype& InArchetype,
        VClass& InClass,
        VArchetype* InNextArchetype,
        int32& BaseIndex,
        TFunction<void(int32&)> WalkSuper,
        TFunction<void(VArchetype::VEntry&, int32, VClass&)> FieldCallbackProc);
 
    VShape* BindNativeClass(FAllocationContext Context, bool bImported);
 
    void CommonPrepare(FAllocationContext Context, FInitOrValidateUStruct& InitOrValidate, UStruct* Type);
    void Prepare(FAllocationContext Context, FInitOrValidateUVerseStruct& InitOrValidate, UVerseStruct* Type);
    void Prepare(FAllocationContext Context, FInitOrValidateUVerseClass& InitOrValidate, UVerseClass* Type);
 
    VShape* CreateShapeForUStruct(
        FAllocationContext Context,
        TFunction<FProperty*(VArchetype::VEntry&, int32)>&& CreateProperty,
        TFunction<UFunction*(VArchetype::VEntry&)>&& CreateFunction);
    VShape* CreateShapeForExistingUStruct(FAllocationContext Context);
    UFunction* MaybeCreateUFunctionForCallee(Verse::FAllocationContext Context, VValue Callee);
 
    void ConstructNativeDefaultObject(FRunningContext Context, bool bRequireConcreteEffectToken);
    static FOpResult MarkSuperFieldsCreated(FRunningContext Context, VValue Self, TArrayView<VValue> Arguments);
 
    EKind Kind;
    EFlags Flags;
 
    // Super classes and interfaces. The single superclass is always first.
    int32 NumInherited;
 
    TWriteBarrier<VArchetype> Archetype;
 
    TWriteBarrier<VFunction> Constructor;
 
    // TODO: (yiliang.siew) This should be a weak map when we can support it in the GC. https://jira.it.epicgames.com/browse/SOL-5312
    TMap<TWriteBarrier<VUniqueStringSet>, TWriteBarrier<VEmergentType>, FDefaultSetAllocator, FEmergentTypesCacheKeyFuncs> EmergentTypesCache;
 
    TWriteBarrier<VClass> Inherited[];
 
    friend class FInterpreter;
    friend ::UVerseClass;
    friend ::UVerseStruct;
};
 
ENUM_CLASS_FLAGS(VClass::EFlags)
} // namespace Verse
#endif // WITH_VERSE_VM