CoreRedirectsContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "RedirectionSummary.h"
#include "UObject/CoreRedirects.h"
 
#define UE_API COREUOBJECT_API
 
struct FCoreRedirectsContext
{
    enum class EFlags : uint32
    {
        None                        = 0,
        DebugMode                   = 1 << 0,   // Enables extra validation and logging
        ValidateAddedRedirects      = 1 << 1,   // Validates CoreRedirects are well-formed before addition
        UseRedirectionSummary       = 1 << 2,   // New redirects will be appended to the RedirectionSummary
 
        Default = ValidateAddedRedirects | UseRedirectionSummary
    };
 
    /*
    * Returns the global context used by FCoreRedirects when no new context has been provided as an override.
    */
    static UE_API FCoreRedirectsContext& GetGlobalContext();
 
    /*
    * Returns the current context used by FCoreRedirects for the current thread. If no new context has been applied,
    * a global context is used for all threads.
    */
    static UE_API FCoreRedirectsContext& GetThreadContext();
 
    /*
    * Changes the context for FCoreRedirects calls to use for the current thread. The passed in context must remain
    * valid until PopThreadContext is called.
    */
    static UE_API void SetThreadContext(FCoreRedirectsContext& NewContext);
 
    UE_API void InitializeContext();
 
    UE_API FCoreRedirectsContext();
 
    UE_API FCoreRedirectsContext(const FCoreRedirectsContext& OtherContext);
 
    const bool IsInitialized() const;
 
    const bool IsInDebugMode() const;
 
    EFlags GetFlags() const;
 
    void SetFlags(EFlags Flags);
 
    const bool HasValidated() const;
 
    TMap<FName, ECoreRedirectFlags>& GetConfigKeyMap();
 
    FCoreRedirects::FRedirectTypeMap& GetRedirectTypeMap();
 
#if WITH_EDITOR
    FRedirectionSummary& GetRedirectionSummary();
#endif
 
    UE_API FCoreRedirectsContext& operator=(const FCoreRedirectsContext& Other);
 
private:
    friend void FCoreRedirects::ValidateAllRedirects();
    void SetHasValidated();
 
    struct FRWLockWithExclusiveRecursion
    {
        void ReadLock();
 
        void WriteLock();
 
        void WriteUnlock();
 
        void ReadUnlock();
 
    private:
        uint32 LoadWriteLockOwnerThreadIdRelaxed() const;
        void StoreWriteLockOwnerThreadId(uint32 ThreadId, std::memory_order Order = std::memory_order_seq_cst);
 
        FTransactionallySafeRWLock InternalLock;
        std::atomic<uint32> WriteLockOwnerThreadId = 0;
        int32 RecursionCount = 0;
    };
    friend struct FScopeCoreRedirectsReadLockedContext;
    friend struct FScopeCoreRedirectsWriteLockedContext;
 
private:
    std::atomic<bool> bInitialized;
    std::atomic<EFlags> Flags;
    bool bValidatedOnce;
    TMap<FName, ECoreRedirectFlags> ConfigKeyMap;
    FCoreRedirects::FRedirectTypeMap RedirectTypeMap;
    FRWLockWithExclusiveRecursion RWLock;
 
#if WITH_EDITOR
    FRedirectionSummary RedirectionSummary;
#endif
};
ENUM_CLASS_FLAGS(FCoreRedirectsContext::EFlags);
 
struct FScopeCoreRedirectsContext
{
    UE_API FScopeCoreRedirectsContext();
    UE_API FScopeCoreRedirectsContext(FCoreRedirectsContext& ContextToCopyFrom);
    UE_API ~FScopeCoreRedirectsContext();
 
    FCoreRedirectsContext ScopeContext;
    FCoreRedirectsContext& ContextToRestore;
};
 
 
struct FScopeCoreRedirectsReadLockedContext
{
public:
    explicit FScopeCoreRedirectsReadLockedContext(FCoreRedirectsContext& InContext)
        : Context(InContext)
        , NeedsUnlock(true)
    {
        Context.RWLock.ReadLock();
    }
 
    ~FScopeCoreRedirectsReadLockedContext()
    {
        if (NeedsUnlock)
        {
            Context.RWLock.ReadUnlock();
        }
    }
 
    FCoreRedirectsContext& Get() { return Context; }
 
protected:
    enum class EInitFlag
    {
        InitFlag
    };
 
    FScopeCoreRedirectsReadLockedContext(FCoreRedirectsContext& InContext, EInitFlag Unused)
        : Context(InContext)
        , NeedsUnlock(false)
    {}
 
    FCoreRedirectsContext& Context;
    bool NeedsUnlock;
};
 
struct FScopeCoreRedirectsWriteLockedContext : public FScopeCoreRedirectsReadLockedContext
{
public:
    explicit FScopeCoreRedirectsWriteLockedContext(FCoreRedirectsContext& InContext)
        : FScopeCoreRedirectsReadLockedContext(InContext, EInitFlag::InitFlag)
    {
        Context.RWLock.WriteLock();
    }
 
    ~FScopeCoreRedirectsWriteLockedContext()
    {
        Context.RWLock.WriteUnlock();
    }
};
 
// Inline implementations
 
inline const bool FCoreRedirectsContext::IsInitialized() const
{
    // Use an atomic variable rather than take a read lock because we might already be under a read lock
    return bInitialized.load(std::memory_order_acquire);
}
 
inline const bool FCoreRedirectsContext::IsInDebugMode() const
{
    return Flags.load(std::memory_order_relaxed) == EFlags::DebugMode;
}
 
inline FCoreRedirectsContext::EFlags FCoreRedirectsContext::GetFlags() const
{
    // Use an atomic variable rather than take a read lock because we might already be under a read lock
    return Flags.load(std::memory_order_relaxed);
}
 
inline void FCoreRedirectsContext::SetFlags(FCoreRedirectsContext::EFlags NewFlags)
{
    return Flags.store(NewFlags, std::memory_order_relaxed);
}
 
inline const bool FCoreRedirectsContext::HasValidated() const 
{ 
    return bValidatedOnce; 
}
 
inline void FCoreRedirectsContext::SetHasValidated() 
{ 
    bValidatedOnce = true;
}
 
inline TMap<FName, ECoreRedirectFlags>& FCoreRedirectsContext::GetConfigKeyMap()
{ 
    return ConfigKeyMap;
}
 
inline FCoreRedirects::FRedirectTypeMap& FCoreRedirectsContext::GetRedirectTypeMap() 
{ 
    return RedirectTypeMap;
}
 
#if WITH_EDITOR
inline FRedirectionSummary& FCoreRedirectsContext::GetRedirectionSummary() 
{ 
    return RedirectionSummary;
}
#endif
 
#undef UE_API