VVMShape.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/Map.h"
#include "VVMCell.h"
#include "VVMUniqueString.h"
#include "VVMWriteBarrier.h"
 
class FVerseVMEngineEnvironment;
class FProperty;
 
namespace Verse
{
struct FAccessContext;
struct VUniqueString;
struct VEmergentType;
 
template <Verse::VCppClassInfo* ClassInfo>
struct TGlobalTrivialEmergentTypePtr;
 
enum class EFieldType : int8
{
    // The field's value is stored in a VObject.
    // e.g. `c := class{ X:int }` or `c := class{ var X:int = 0 }`
    Offset,
 
    // The field's value is a native type stored in a UObject or VNativeStruct.
    FProperty,
    // The field's value is a mutable native type stored in a UObject or VNativeStruct.
    FPropertyVar,
    // The field's value is a VRestValue stored in a UObject or VNativeStruct.
    FVerseProperty,
 
    // The field's value is stored in the shape.
    // This is used for fields default-initialized to a constant, such as methods.
    // e.g. `a := class{ X:int = 3, Y:int = 5, F(Z:int):int = X + Y + Z }; A := a{ X := 8 }
    // Here, `A.Y` and `A.F` are stored in the shape, while `A.X` is stored in the object.
    Constant,
};
 
struct VShape : VCell
{
    struct VEntry
    {
        union
        {
            uint64 Index;
 
            FProperty* UProperty;
 
            TWriteBarrier<VValue> Value;
        };
 
        EFieldType Type;
 
        // Must have a copy/move constructor in order to be used with `TMap` as the value type.
        VEntry(const VEntry& Other);
        VEntry(VEntry&& Other)
            : VEntry(Other) {}
 
        static VEntry Offset() { return {}; }
        // TODO: (yiliang.siew) Should these initialize to `VRestValue`s? Otherwise `Def` won't work correctly.
        static VEntry Property(FProperty* InProperty = nullptr) { return {InProperty, EFieldType::FProperty}; }
        static VEntry PropertyVar(FProperty* InProperty = nullptr) { return {InProperty, EFieldType::FPropertyVar}; }
        static VEntry VerseProperty(FProperty* InProperty = nullptr) { return {InProperty, EFieldType::FVerseProperty}; }
        static VEntry Constant(FAccessContext Context, VValue InConstant) { return {Context, InConstant}; }
 
        bool operator==(const VEntry& Other) const;
 
        bool IsProperty() const { return Type == EFieldType::FProperty || Type == EFieldType::FPropertyVar || Type == EFieldType::FVerseProperty; }
        bool IsAccessor() const;
 
    private:
        VEntry();
        VEntry(FProperty* InProperty, EFieldType InType);
        VEntry(FAccessContext Context, VValue InConstant);
    };
 
    struct FFieldsMapKeyFuncs : TDefaultMapKeyFuncs<TWriteBarrier<VUniqueString>, VEntry, /*bInAllowDuplicateKeys*/ false>
    {
        static bool Matches(KeyInitType A, KeyInitType B);
        static bool Matches(KeyInitType A, const VUniqueString& B);
        static uint32 GetKeyHash(KeyInitType Key);
        static uint32 GetKeyHash(const VUniqueString& Key);
    };
 
    using FieldsMap = TMap<TWriteBarrier<VUniqueString>, VEntry, FDefaultSetAllocator, FFieldsMapKeyFuncs>;
 
    DECLARE_DERIVED_VCPPCLASSINFO(COREUOBJECT_API, VCell);
    COREUOBJECT_API static TGlobalTrivialEmergentTypePtr<&StaticCppClassInfo> GlobalTrivialEmergentType;
 
    COREUOBJECT_API static VShape* New(FAllocationContext Context, FieldsMap&& InFields);
 
    const VEntry* GetField(const VUniqueString& Name) const;
    const VEntry& GetField(int32 FieldIndex) const;
    const int32 GetFieldIndex(FAllocationContext Context, VUniqueString& Name) const
    {
        return Fields.FindId({Context, Name}).AsInteger();
    }
    const int32 GetFieldIndex(TWriteBarrier<VUniqueString>& Name) const
    {
        return Fields.FindId(Name).AsInteger();
    }
    const int32 GetMaxFieldIndex() const
    {
        return Fields.GetMaxIndex();
    }
 
    uint64 GetNumFields() const;
 
    bool operator==(const VShape& Other) const;
 
    VShape& CopyToMeltedShape(FAllocationContext);
 
    FieldsMap::TIterator CreateFieldsIterator() { return Fields.CreateIterator(); }
 
    VShape(FAllocationContext Context, FieldsMap&& InFields);
 
    FieldsMap Fields;
 
    uint64 NumIndexedFields;
 
    // Perhaps we should store this as a bit in the VCell header
    bool bHasAccessors = false;
};
 
} // namespace Verse
#endif // WITH_VERSE_VM