ScopeLock.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Misc/NotNull.h"
#include "HAL/CriticalSection.h"
 
namespace UE
{
    // RAII-style scope locking of a synchronization primitive.
    // `MutexType` is required to implement `Lock` and `Unlock` methods.
    // Example:
    //  {
    //      TScopeLock<FCriticalSection> ScopeLock(CriticalSection);
    //      ...
    //  }
    template<typename MutexType>
    class TScopeLock
    {
    public:
        UE_NONCOPYABLE(TScopeLock);
 
        [[nodiscard]] explicit TScopeLock(MutexType& InMutex) : Mutex(&InMutex)
        {
            check(Mutex);
            Mutex->Lock();
        }
 
        ~TScopeLock()
        {
            Unlock();
        }
 
        void Unlock()
        {
            if (Mutex)
            {
                Mutex->Unlock();
                Mutex = nullptr;
            }
        }
 
    private:
        MutexType* Mutex;
    };
 
    // RAII-style scope locking of a synchronization primitive. Same
    // as TScopeLock except taking the lock is conditional.
    template<typename MutexType>
    class TConditionalScopeLock
    {
    public:
        UE_NONCOPYABLE(TConditionalScopeLock);
 
        [[nodiscard]] explicit TConditionalScopeLock(MutexType& InMutex, bool bShouldLock)
            : Mutex(bShouldLock ? &InMutex : nullptr)
        {
            if (bShouldLock)
            {
                check(Mutex);
                Mutex->Lock();
            }
        }
 
        ~TConditionalScopeLock()
        {
            Unlock();
        }
 
        void Unlock()
        {
            if (Mutex)
            {
                Mutex->Unlock();
                Mutex = nullptr;
            }
        }
 
    private:
        MutexType* Mutex;
    };
 
    // RAII-style scope unlocking of a synchronization primitive.
    // `MutexType` is required to implement `Lock` and `Unlock` methods.
    // Example:
    //  {
    //      TScopeLock<FCriticalSection> ScopeLock(CriticalSection);
    //      for (FElementType& Element : ThreadUnsafeContainer)
    //      {
    //          TScopeUnlock<FCriticalSection> ScopeUnlock(&CriticalSection);
    //          Process(Element);
    //      }
    //  }
    template<typename MutexType>
    class TScopeUnlock
    {
    public:
        UE_NONCOPYABLE(TScopeUnlock);
 
        [[nodiscard]] explicit TScopeUnlock(MutexType* InMutex) : Mutex(InMutex)
        {
            if (Mutex)
            {
                Mutex->Unlock();
            }
        }
 
        ~TScopeUnlock()
        {
            if (Mutex)
            {
                Mutex->Lock();
            }
        }
 
    private:
        MutexType* Mutex;
    };
}
 
class FScopeLock : private UE::TScopeLock<FCriticalSection>
{
public:
    [[nodiscard]] explicit FScopeLock(TNotNull<FCriticalSection*> InSyncObject) : UE::TScopeLock<FCriticalSection>(*InSyncObject)
    {
    }
 
    using UE::TScopeLock<FCriticalSection>::Unlock;
};
 
class FScopeUnlock : private UE::TScopeUnlock<FCriticalSection>
{
public:
    [[nodiscard]] explicit FScopeUnlock(FCriticalSection* InSyncObject) : UE::TScopeUnlock<FCriticalSection>(InSyncObject)
    {
    }
};