SharedLock.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/LockTags.h"
#include "Misc/AssertionMacros.h"
 
namespace UE
{
 
// Note: FSharedRecursiveMutex has specialized these lock types.
 
template <typename LockType>
class TSharedLock final
{
public:
    TSharedLock(const TSharedLock&) = delete;
    TSharedLock& operator=(const TSharedLock&) = delete;
 
    [[nodiscard]] inline explicit TSharedLock(LockType& Lock)
        : Mutex(Lock)
    {
        Mutex.LockShared();
    }
 
    inline ~TSharedLock()
    {
        Mutex.UnlockShared();
    }
 
private:
    LockType& Mutex;
};
 
template <typename LockType>
class TDynamicSharedLock final
{
public:
    TDynamicSharedLock() = default;
 
    TDynamicSharedLock(const TDynamicSharedLock&) = delete;
    TDynamicSharedLock& operator=(const TDynamicSharedLock&) = delete;
 
    [[nodiscard]] inline explicit TDynamicSharedLock(LockType& Lock)
        : Mutex(&Lock)
    {
        Mutex->LockShared();
        bLocked = true;
    }
 
    [[nodiscard]] inline explicit TDynamicSharedLock(LockType& Lock, FDeferLock)
        : Mutex(&Lock)
    {
    }
 
    [[nodiscard]] inline TDynamicSharedLock(TDynamicSharedLock&& Other)
        : Mutex(Other.Mutex)
        , bLocked(Other.bLocked)
    {
        Other.Mutex = nullptr;
        Other.bLocked = false;
    }
 
    inline TDynamicSharedLock& operator=(TDynamicSharedLock&& Other)
    {
        if (bLocked)
        {
            Mutex->UnlockShared();
        }
        Mutex = Other.Mutex;
        bLocked = Other.bLocked;
        Other.Mutex = nullptr;
        Other.bLocked = false;
        return *this;
    }
 
    inline ~TDynamicSharedLock()
    {
        if (bLocked)
        {
            Mutex->UnlockShared();
        }
    }
 
    bool TryLock()
    {
        check(!bLocked);
        check(Mutex);
        bLocked = Mutex->TryLockShared();
        return bLocked;
    }
 
    void Lock()
    {
        check(!bLocked);
        check(Mutex);
        Mutex->LockShared();
        bLocked = true;
    }
 
    void Unlock()
    {
        check(bLocked);
        bLocked = false;
        Mutex->UnlockShared();
    }
 
    inline bool OwnsLock() const
    {
        return bLocked;
    }
 
    inline explicit operator bool() const
    {
        return OwnsLock();
    }
 
private:
    LockType* Mutex = nullptr;
    bool bLocked = false;
};
 
} // UE