FieldAccessor.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/Function.h"
 
template <typename T>
class TFieldPtrAccessor
{
public:
    // Owned by another class that will control the value. Will not use the internal value.
    TFieldPtrAccessor(TFunction<T* ()> InGet, TFunction<void(T*)> InSet)
        : Get(MoveTemp(InGet))
        , Set(MoveTemp(InSet))
    {
    }
 
    // Self-owned value with initializer
    TFieldPtrAccessor(T* InValue = nullptr)
        : CapturedValue(InValue)
        , Get([this]()-> T* { return CapturedValue; })
        , Set([this](T* InPtr) { CapturedValue = InPtr; })
    {
    }
 
    // Capture the value of the passed field accessor and becomes self-owned.
    TFieldPtrAccessor(const TFieldPtrAccessor& Other)
        : CapturedValue(Other.Get())
        , Get([this]()-> T* { return CapturedValue; })
        , Set([this](T* InPtr) { CapturedValue = InPtr; })
    {
    }
 
    TFieldPtrAccessor& operator= (const TFieldPtrAccessor& Other) = delete;
    TFieldPtrAccessor& operator=(TFieldPtrAccessor&&) = delete;
 
    T* operator ->() const
    {
        return Get();
    }
 
    operator bool() const
    {
        return Get() != nullptr;
    }
 
    operator T* () const
    {
        return Get();
    }
 
    template<typename OtherT>
    explicit operator OtherT* () const
    {
        return (OtherT*)Get();
    }
 
    bool operator!() const
    {
        return Get() == nullptr;
    }
 
    bool operator == (const T* OtherPtr) const
    {
        return Get() == OtherPtr;
    }
 
    bool operator != (const T* OtherPtr) const
    {
        return Get() != OtherPtr;
    }
 
    TFieldPtrAccessor& operator= (T* OtherPtr)
    {
        Set(OtherPtr);
        return *this;
    }
 
private:
    // This is used only when capturing the value from another TFieldPtrAccessor.
    T* CapturedValue = nullptr;
    TFunction< T* ()> Get;
    TFunction<void(T*)> Set;
};