UniversalObjectLocatorFragment.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "UObject/Class.h"
#include "UniversalObjectLocatorFwd.h"
#include "UniversalObjectLocatorFragmentType.h"
#include "UniversalObjectLocatorFragmentTypeHandle.h"
#include "UniversalObjectLocatorFragmentDebugging.h"
#include "Templates/Function.h"
#include "UniversalObjectLocatorFragment.generated.h"
 
 
USTRUCT(BlueprintType)
struct alignas(8) FUniversalObjectLocatorFragment
{
    GENERATED_BODY()
 
    using FParseStringResult = UE::UniversalObjectLocator::FParseStringResult;
    using FParseStringParams = UE::UniversalObjectLocator::FParseStringParams;
 
    static constexpr FAsciiSet ValidFragmentTypeCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-";
    // Valid fragment delimiters are those that are allowable by RFC3986 for the query part (unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?") excluding '&' which we use to separate fragments within a path
    static constexpr FAsciiSet ValidFragmentDelimiters = "%!$'()*+,;=/?:@.~";
    static constexpr FAsciiSet ValidFragmentPayloadCharacters = ValidFragmentTypeCharacters | ValidFragmentDelimiters;
 
#if WITH_EDITORONLY_DATA
    static constexpr SIZE_T SizeInMemory = 64;
#else
    static constexpr SIZE_T SizeInMemory = 32;
#endif
 
 
    template<typename T, typename ...ArgTypes>
    FUniversalObjectLocatorFragment(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InHandle, ArgTypes&& ...InArgs);
 
 
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment(const UE::UniversalObjectLocator::FFragmentType& InFragmentType);
 
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment(const UObject* InObject, UObject* Context);
 
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment();
 
    UNIVERSALOBJECTLOCATOR_API ~FUniversalObjectLocatorFragment();
 
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment(const FUniversalObjectLocatorFragment& RHS);
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment& operator=(const FUniversalObjectLocatorFragment& RHS);
 
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment(FUniversalObjectLocatorFragment&& RHS);
    UNIVERSALOBJECTLOCATOR_API FUniversalObjectLocatorFragment& operator=(FUniversalObjectLocatorFragment&& RHS);
 
    UNIVERSALOBJECTLOCATOR_API friend bool operator==(const FUniversalObjectLocatorFragment& A, const FUniversalObjectLocatorFragment& B);
    UNIVERSALOBJECTLOCATOR_API friend bool operator!=(const FUniversalObjectLocatorFragment& A, const FUniversalObjectLocatorFragment& B);
    UNIVERSALOBJECTLOCATOR_API friend uint32 GetTypeHash(const FUniversalObjectLocatorFragment& Fragment);
public:
 
    UNIVERSALOBJECTLOCATOR_API UE::UniversalObjectLocator::FResolveResult Resolve(const UE::UniversalObjectLocator::FResolveParams& Params) const;
 
    bool IsEmpty() const
    {
        return !FragmentType.IsValid();
    }
 
public:
 
    UNIVERSALOBJECTLOCATOR_API void Reset();
 
    UNIVERSALOBJECTLOCATOR_API void Reset(const UObject* InObject, UObject* Context);
 
    UNIVERSALOBJECTLOCATOR_API void Reset(const UObject* InObject, UObject* Context, TFunctionRef<bool(UE::UniversalObjectLocator::FFragmentTypeHandle)> CanUseFragmentType);
 
public:
 
    UNIVERSALOBJECTLOCATOR_API void ToString(FStringBuilderBase& OutString) const;
 
    UNIVERSALOBJECTLOCATOR_API FParseStringResult TryParseString(FStringView InString, const FParseStringParams& InParams);
 
    UNIVERSALOBJECTLOCATOR_API FParseStringResult TryParseFragmentType(FStringView InString, const FParseStringParams& InParams);
 
    UNIVERSALOBJECTLOCATOR_API FParseStringResult TryParseFragmentPayload(FStringView InString, const FParseStringParams& InParams);
 
public:
 
    template<typename T>
    T* GetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType);
 
    template<typename T>
    const T* GetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType) const;
 
    template<typename T>
    bool TryGetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType, T*& OutData);
 
    template<typename T>
    bool TryGetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType, const T*& OutData) const;
 
    UNIVERSALOBJECTLOCATOR_API void* GetPayload();
 
    UNIVERSALOBJECTLOCATOR_API const void* GetPayload() const;
 
    UNIVERSALOBJECTLOCATOR_API const UE::UniversalObjectLocator::FFragmentType* GetFragmentType() const;
 
    UNIVERSALOBJECTLOCATOR_API UScriptStruct* GetFragmentStruct() const;
 
    UNIVERSALOBJECTLOCATOR_API UE::UniversalObjectLocator::FFragmentTypeHandle GetFragmentTypeHandle() const;
 
public:
 
    /*~ Begin TStructOpsTypeTraits implementation */
    UNIVERSALOBJECTLOCATOR_API bool Serialize(FArchive& Ar);
    UNIVERSALOBJECTLOCATOR_API void AddStructReferencedObjects(FReferenceCollector& Collector);
    UNIVERSALOBJECTLOCATOR_API bool ExportTextItem(FString& ValueStr, const FUniversalObjectLocatorFragment& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    UNIVERSALOBJECTLOCATOR_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText, FArchive* InSerializingArchive = nullptr);
    UNIVERSALOBJECTLOCATOR_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
    UNIVERSALOBJECTLOCATOR_API void GetPreloadDependencies(TArray<UObject*>& OutDeps);
    /*~ End TStructOpsTypeTraits implementation */
 
protected:
 
 
#if DO_CHECK
    UNIVERSALOBJECTLOCATOR_API void CheckPayloadType(UScriptStruct* TypeToCompare) const;
#else
    FORCEINLINE static constexpr void CheckPayloadType(void* TypeToCompare)
    {
    }
#endif
 
protected:
 
    struct FAllocatedPayload
    {
#if UE_UNIVERSALOBJECTLOCATOR_DEBUG
        void* DebugVFTablePtr;
#endif
        void* Payload;
    };
 
    UNIVERSALOBJECTLOCATOR_API FAllocatedPayload AllocatePayload(size_t Size, size_t Alignment);
 
    void DefaultConstructPayload(const UE::UniversalObjectLocator::FFragmentType& InFragmentType);
 
    void DestroyPayload();
 
private:
 
    uint32 GetDebugHeaderOffset() const
    {
        // Special case for DebugHeaderSizeLog2==0 which signifies no offset rather than 2^0 = 1 byte.
        // We do this using a branchless bitmask that always unsets the first bit (which can never be set, because we always return a power of 2 > 1)
        return (1ul << DebugHeaderSizeLog2) & (~1ul);
    }
 
#if UE_UNIVERSALOBJECTLOCATOR_DEBUG
    /*~ Utility symbol name to guarantee that FFragmentType can be resolved within the context of a FUniversalObjectLocatorFragment within natvis expressions */
    struct FDebuggableFragmentType
    {
        using Type = UE::UniversalObjectLocator::FFragmentType;
    };
    struct FDebuggableFragment
    {
        using Type = UE::UniversalObjectLocator::IFragmentPayload;
    };
#endif
 
    /*
     * Payload data - implicitly aligned to a 8 byte boundary since it's the first member.
     * Given payload type T, this is either a type-erased T() value (where bIsInline==1),
     *    or a T* to a heap allocated T (where bIsInline==0)
     * SizeInMemory is specifically defined by the desired overall size of FUniversalObjectLocatorFragment::SizeInMemory, minus space for other members
     */
    uint8 Data[SizeInMemory-2];
 
    UE::UniversalObjectLocator::FFragmentTypeHandle FragmentType;
 
    /*~ 1 Byte of flags */
    uint8 bIsInitialized : 1;
    uint8 bIsInline : 1;
    uint8 DebugHeaderSizeLog2 : 6;
};
 
template<>
struct TStructOpsTypeTraits<FUniversalObjectLocatorFragment> : public TStructOpsTypeTraitsBase2<FUniversalObjectLocatorFragment>
{
    enum
    {
        WithSerializer = true,
        WithCopy = true,
        WithIdenticalViaEquality = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
        WithAddStructReferencedObjects = true,
    };
};
 
 
template<typename T, typename ...ArgTypes>
FUniversalObjectLocatorFragment::FUniversalObjectLocatorFragment(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InHandle, ArgTypes&& ...InArgs)
    : FragmentType(InHandle)
    , bIsInitialized(0)
    , DebugHeaderSizeLog2(0)
{
    using namespace UE::UniversalObjectLocator;
 
    checkf(InHandle, TEXT("Attempting to construct a new fragment from an invalid fragment type handle - was it registered?"));
 
    FAllocatedPayload Allocation = AllocatePayload(sizeof(T), alignof(T));
 
#if UE_UNIVERSALOBJECTLOCATOR_DEBUG
    // Initialize the fragment vftable if necessary. We can do this without needing the fragment type since we know the type
    new (Allocation.DebugVFTablePtr) TFragmentPayload<T>;
#endif
 
    // Placement new the payload
    new (Allocation.Payload) T{ Forward<ArgTypes>(InArgs)... };
}
 
template<typename T>
T* FUniversalObjectLocatorFragment::GetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType)
{
    if (FragmentType.IsValid() && ensureMsgf(FragmentType == InType, TEXT("Type mismatch when accessing payload data!")))
    {
        return static_cast<T*>(GetPayload());
    }
    return nullptr;
}
 
template<typename T>
const T* FUniversalObjectLocatorFragment::GetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType) const
{
    return const_cast<FUniversalObjectLocatorFragment*>(this)->GetPayloadAs(InType);
}
 
template<typename T>
bool FUniversalObjectLocatorFragment::TryGetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType, T*& OutData)
{
    if (FragmentType.IsValid() && FragmentType == InType)
    {
        OutData = static_cast<T*>(GetPayload());
        return true;
    }
    return false;
}
 
template<typename T>
bool FUniversalObjectLocatorFragment::TryGetPayloadAs(UE::UniversalObjectLocator::TFragmentTypeHandle<T> InType, const T*& OutData) const
{
    if (FragmentType.IsValid() && FragmentType == InType)
    {
        OutData = static_cast<const T*>(GetPayload());
        return true;
    }
    return false;
}
 
 
USTRUCT()
struct FUniversalObjectLocatorEmptyPayload
{
    GENERATED_BODY()
};
 
 
template<typename PayloadType>
struct TUniversalObjectLocatorFragment : FUniversalObjectLocatorFragment
{
    TUniversalObjectLocatorFragment()
        : FUniversalObjectLocatorFragment(PayloadType::FragmentType)
    {
    }
 
    TUniversalObjectLocatorFragment(UE::UniversalObjectLocator::TFragmentTypeHandle<PayloadType> InHandle)
        : FUniversalObjectLocatorFragment(InHandle)
    {
    }
 
    template<typename ...ArgTypes>
    TUniversalObjectLocatorFragment(ArgTypes&& ...InArgs)
        : FUniversalObjectLocatorFragment(PayloadType::FragmentType, Forward<ArgTypes>(InArgs)...)
    {
    }
 
    template<typename ...ArgTypes>
    TUniversalObjectLocatorFragment(UE::UniversalObjectLocator::TFragmentTypeHandle<PayloadType> InHandle, ArgTypes&& ...InArgs)
        : FUniversalObjectLocatorFragment(InHandle, Forward<ArgTypes>(InArgs)...)
    {
    }
 
    PayloadType* GetPayload()
    {
        CheckPayloadType(PayloadType::StaticStruct());
        return static_cast<PayloadType*>(FUniversalObjectLocatorFragment::GetPayload());
    }
 
    const PayloadType* GetPayload() const
    {
        CheckPayloadType(PayloadType::StaticStruct());
        return static_cast<const PayloadType*>(FUniversalObjectLocatorFragment::GetPayload());
    }
};