UniversalObjectLocatorResolveParams.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Async/Future.h"
#include "Misc/TVariant.h"
#include "UniversalObjectLocatorFwd.h"
#include "UniversalObjectLocatorResolveParameterBuffer.h"
#include "UniversalObjectLocatorResolveParams.generated.h"
 
class UObject;
 
UENUM(BlueprintType, meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true"))
enum class ELocatorResolveFlags : uint8
{
    None,
 
    Load = 1 << 0,
 
    Unload = 1 << 1,
 
    Async = 1 << 2,
 
    WillWait = 1 << 3,
 
    AsyncWait = Async | WillWait,
};
ENUM_CLASS_FLAGS(ELocatorResolveFlags)
 
namespace UE::UniversalObjectLocator
{
 
struct FResolveParams
{
    FResolveParams()
        : Context(nullptr)
        , ParameterBuffer(nullptr)
        , Flags(ELocatorResolveFlags::None)
    {
    }
 
    FResolveParams(UObject* InContext)
        : Context(InContext)
        , ParameterBuffer(nullptr)
        , Flags(ELocatorResolveFlags::None)
    {
    }
 
    FResolveParams(UObject* InContext, ELocatorResolveFlags InFlags)
        : Context(InContext)
        , ParameterBuffer(nullptr)
        , Flags(InFlags)
    {
    }
 
    template<typename T>
    const T* FindParameter() const
    {
        return FindParameter(T::ParameterType);
    }
 
    template<typename T>
    const T* FindParameter(TParameterTypeHandle<T> ParameterType) const
    {
        return ParameterBuffer ? ParameterBuffer->FindParameter(ParameterType) : nullptr;
    }
 
    static FResolveParams AsyncFind(UObject* InContext = nullptr)
    {
        return FResolveParams(InContext, ELocatorResolveFlags::Async);
    }
 
    static FResolveParams AsyncLoad(UObject* InContext = nullptr)
    {
        return FResolveParams(InContext, ELocatorResolveFlags::Async | ELocatorResolveFlags::Load);
    }
 
    static FResolveParams AsyncUnload(UObject* InContext)
    {
        return FResolveParams(InContext, ELocatorResolveFlags::Async | ELocatorResolveFlags::Unload);
    }
 
    static FResolveParams SyncFind(UObject* InContext = nullptr)
    {
        return FResolveParams(InContext);
    }
 
    static FResolveParams SyncLoad(UObject* InContext = nullptr)
    {
        return FResolveParams(InContext, ELocatorResolveFlags::Load);
    }
 
    static FResolveParams SyncUnload(UObject* InContext)
    {
        return FResolveParams(InContext, ELocatorResolveFlags::Unload);
    }
 
    UObject* Context;
 
    FResolveParameterBuffer* ParameterBuffer;
 
    ELocatorResolveFlags Flags;
};
 
template<int InlineSize>
struct TResolveParamsWithBuffer : TInlineResolveParameterBuffer<InlineSize>, FResolveParams
{
    TResolveParamsWithBuffer()
    {
        ParameterBuffer = this;
    }
 
    TResolveParamsWithBuffer(UObject* InContext)
        : FResolveParams(InContext)
    {
        ParameterBuffer = this;
    }
 
    TResolveParamsWithBuffer(UObject* InContext, ELocatorResolveFlags InFlags)
        : FResolveParams(InContext, InFlags)
    {
        ParameterBuffer = this;
    }
};
 
 
 
 
struct FResolveResultFlags
{
    FResolveResultFlags()
        : bWasLoaded(0)
        , bWasLoadedIndirectly(0)
    {
    }
 
    uint8 bWasLoaded : 1;
    uint8 bWasLoadedIndirectly : 1;
};
 
struct FResolveResultData
{
    FResolveResultData()
        : Object(nullptr)
    {
    }
 
    FResolveResultData(UObject* InObject, FResolveResultFlags InFlags = FResolveResultFlags())
        : Object(InObject)
        , Flags(InFlags)
    {
    }
 
    UObject* Object = nullptr;
 
    FResolveResultFlags Flags;
};
 
 
struct FResolveResult
{
    FResolveResult()
        : Value(TInPlaceType<FResolveResultData>())
    {
    }
 
    FResolveResult(FResolveResultData InValue)
        : Value(TInPlaceType<FResolveResultData>(), MoveTemp(InValue))
    {
    }
 
    FResolveResult(TFuture<FResolveResultData>&& InFuture)
        : Value(TInPlaceType<TFuture<FResolveResultData>>(), MoveTemp(InFuture))
    {
    }
 
    FResolveResult(const FResolveResult&) = delete;
    void operator=(const FResolveResult&) = delete;
 
    FResolveResult(FResolveResult&&) = default;
    FResolveResult& operator=(FResolveResult&&) = default;
 
public:
 
    bool IsAsync() const
    {
        return Value.IsType<TFuture<FResolveResultData>>();
    }
 
    TFuture<FResolveResultData> ReleaseFuture()
    {
        if (TFuture<FResolveResultData>* Future = Value.TryGet<TFuture<FResolveResultData>>())
        {
            return MoveTemp(*Future);
        }
        return TFuture<FResolveResultData>();
    }
 
    bool NeedsWait() const
    {
        if (const TFuture<FResolveResultData>* Future = Value.TryGet<TFuture<FResolveResultData>>())
        {
            return !Future->IsReady();
        }
        return false;
    }
 
    const FResolveResultData* SyncGetNoWait()
    {
        const TFuture<FResolveResultData>* Future = Value.TryGet<TFuture<FResolveResultData>>();
        if (Future)
        {
            if (!Future->IsReady())
            {
                return nullptr;
            }
 
            FResolveResultData Data = Future->Get();
            Value.Emplace<FResolveResultData>(Data);
        }
 
        return &Value.Get<FResolveResultData>();
    }
 
    FResolveResultData SyncGet() const
    {
        const TFuture<FResolveResultData>* Future = Value.TryGet<TFuture<FResolveResultData>>();
        if (Future)
        {
            return Future->Get();
        }
        else
        {
            return Value.Get<FResolveResultData>();
        }
    }
 
    void AsyncGet(TUniqueFunction<void(const FResolveResultData&)>&& OnComplete)
    {
        TFuture<FResolveResultData>* Future = Value.TryGet<TFuture<FResolveResultData>>();
        if (Future)
        {
            if (Future->IsReady())
            {
                OnComplete(Future->Get());
            }
            else
            {
                Future->Then(
                    [OnComplete = MoveTemp(OnComplete)](TFuture<FResolveResultData>&& InValue)
                    {
                        OnComplete(InValue.Get());
                    }
                );
            }
        }
        else
        {
            OnComplete(MoveTemp(Value.Get<FResolveResultData>()));
        }
    }
 
private:
 
    TVariant<
        FResolveResultData,
        TFuture<FResolveResultData>
    > Value;
};
 
} // namespace UE::UniversalObjectLocator