IUniversalObjectLocatorModule.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Modules/ModuleInterface.h"
#include "UniversalObjectLocatorFwd.h"
#include "UniversalObjectLocatorFragmentTypeHandle.h"
#include "UniversalObjectLocatorFragmentType.h"
#include "UniversalObjectLocatorStringParams.h"
#include "UniversalObjectLocatorInitializeResult.h"
#include "UniversalObjectLocatorFragment.h"
#include "UniversalObjectLocatorFragmentType.h"
#include "Concepts/GetTypeHashable.h"
#include "Templates/UnrealTypeTraits.h"
#include "Misc/GeneratedTypeName.h"
 
struct FSubObjectLocator;
 
namespace UE::UniversalObjectLocator
{
 
struct FFragmentTypeParameters
{
    FFragmentTypeParameters(FName InFragmentTypeID, FText InDisplayText)
        : DisplayText(InDisplayText)
        , FragmentTypeID(InFragmentTypeID)
        , Flags(EFragmentTypeFlags::None)
    {
    }
 
    FText DisplayText;
    FName FragmentTypeID;
    FName PrimaryEditorType;
    EFragmentTypeFlags Flags;
};
 
class IUniversalObjectLocatorModule
    : public IModuleInterface
{
public:
 
 
    template<typename PayloadStructType
        UE_REQUIRES(
            // Payloads must be equality-comparable (we don't use the CEqualityComparable concept here because we need to make sure the ICppStructOps are set up correctly)
            (TStructOpsTypeTraits<PayloadStructType>::WithIdenticalViaEquality || TStructOpsTypeTraits<PayloadStructType>::WithIdentical) &&
            // Payloads must be type-hashable
            TModels_V<CGetTypeHashable, PayloadStructType>
        )
    >
    TFragmentTypeHandle<PayloadStructType> RegisterFragmentType(FFragmentTypeParameters& FragmentTypeParameters)
    {
        checkf(FragmentTypeParameters.FragmentTypeID != NAME_None, TEXT("'None' is not a valid Fragment Type ID for type %s"), GetGeneratedTypeName<PayloadStructType>());
        checkf(!FAsciiSet::HasAny(*FragmentTypeParameters.FragmentTypeID.ToString(), ~FUniversalObjectLocatorFragment::ValidFragmentTypeCharacters), TEXT("Fragment Type ID '%s' contains invalid characters"), *FragmentTypeParameters.FragmentTypeID.ToString());
 
        FFragmentType NewFragmentType;
        NewFragmentType.FragmentTypeID     = FragmentTypeParameters.FragmentTypeID;
        NewFragmentType.PrimaryEditorType  = FragmentTypeParameters.PrimaryEditorType;
        NewFragmentType.Flags              = FragmentTypeParameters.Flags;
        NewFragmentType.PayloadType        = PayloadStructType::StaticStruct();
 
        // Static bindings
        NewFragmentType.StaticBindings.Priority = PayloadStructType::ComputePriority;
 
        // Member function bindings
        NewFragmentType.InstanceBindings.Resolve = [](const void* Payload, const FResolveParams& Params) -> FResolveResult
        {
            return static_cast<const PayloadStructType*>(Payload)->Resolve(Params);
        };
        NewFragmentType.InstanceBindings.Initialize = [](void* Payload, const FInitializeParams& InParams) -> FInitializeResult
        {
            return static_cast<PayloadStructType*>(Payload)->Initialize(InParams);
        };
        NewFragmentType.InstanceBindings.ToString = [](const void* Payload, FStringBuilderBase& OutStringBuilder)
        {
            return static_cast<const PayloadStructType*>(Payload)->ToString(OutStringBuilder);
        };
        NewFragmentType.InstanceBindings.TryParseString = [](void* Payload, FStringView InString, const FParseStringParams& Params) -> FParseStringResult
        {
            return static_cast<PayloadStructType*>(Payload)->TryParseString(InString, Params);
        };
#if UE_UNIVERSALOBJECTLOCATOR_DEBUG
        NewFragmentType.StaticBindings.FragmentDebugInitializer = [](void* Payload)
        {
            new (Payload) TFragmentPayload<PayloadStructType>;
        };
#endif
        return TFragmentTypeHandle<PayloadStructType>(RegisterFragmentTypeImpl(NewFragmentType));
    }
 
    template<typename ParameterType>
    TParameterTypeHandle<ParameterType> RegisterParameterType()
    {
        return TParameterTypeHandle<ParameterType>(RegisterParameterTypeImpl(ParameterType::StaticStruct()));
    }
 
    void UnregisterParameterType(FParameterTypeHandle InHandle)
    {
        UnregisterParameterTypeImpl(InHandle);
    }
 
    template<typename PayloadStructType>
    void UnregisterFragmentType(TFragmentTypeHandle<PayloadStructType> FragmentType)
    {
        UnregisterFragmentTypeImpl(FragmentType);
    }
 
private:
 
    virtual FFragmentTypeHandle RegisterFragmentTypeImpl(const FFragmentType& FragmentType) = 0;
    virtual void UnregisterFragmentTypeImpl(FFragmentTypeHandle FragmentType) = 0;
 
    virtual FParameterTypeHandle RegisterParameterTypeImpl(UScriptStruct* Struct) = 0;
    virtual void UnregisterParameterTypeImpl(FParameterTypeHandle ParameterType) = 0;
};
 
 
} // namespace UE::UniversalObjectLocator