ValueOrError.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/Optional.h"
#include "Misc/TVariant.h"
#include "Templates/Tuple.h"
#include "Templates/UnrealTemplate.h"
#include <type_traits>
 
template <typename... ArgTypes>
struct TValueOrError_ValueProxy
{
    [[nodiscard]] explicit TValueOrError_ValueProxy(ArgTypes&&... InArgs UE_LIFETIMEBOUND)
        : Args(Forward<ArgTypes>(InArgs)...)
    {
    }
 
    TTuple<ArgTypes&&...> Args;
};
 
template <typename... ArgTypes>
struct TValueOrError_ErrorProxy
{
    [[nodiscard]] explicit TValueOrError_ErrorProxy(ArgTypes&&... InArgs UE_LIFETIMEBOUND)
        : Args(Forward<ArgTypes>(InArgs)...)
    {
    }
 
    TTuple<ArgTypes&&...> Args;
};
 
template <typename... ArgTypes>
[[nodiscard]] UE_REWRITE TValueOrError_ValueProxy<ArgTypes...> MakeValue(ArgTypes&&... Args UE_LIFETIMEBOUND)
{
    return TValueOrError_ValueProxy<ArgTypes...>(Forward<ArgTypes>(Args)...);
}
 
template <typename... ArgTypes>
[[nodiscard]] UE_REWRITE TValueOrError_ErrorProxy<ArgTypes...> MakeError(ArgTypes&&... Args UE_LIFETIMEBOUND)
{
    return TValueOrError_ErrorProxy<ArgTypes...>(Forward<ArgTypes>(Args)...);
}
 
template <typename ValueType, typename ErrorType>
class TValueOrError
{
    static_assert(!std::is_reference_v<ValueType> && !std::is_reference_v<ErrorType>, "ValueType and ErrorType cannot be references");
 
    struct FWrapErrorType
    {
        template <typename... ArgTypes>
        FWrapErrorType(ArgTypes&&... Args) : Error(Forward<ArgTypes>(Args)...) {}
        ErrorType Error;
    };
 
    struct FEmptyType
    {
    };
 
    template <typename... ArgTypes, uint32... ArgIndices>
    [[nodiscard]] inline TValueOrError(TValueOrError_ValueProxy<ArgTypes...>&& Proxy, TIntegerSequence<uint32, ArgIndices...>)
        : Variant(TInPlaceType<ValueType>(), MoveTemp(Proxy.Args).template Get<ArgIndices>()...)
    {
    }
 
    template <typename... ArgTypes, uint32... ArgIndices>
    [[nodiscard]] inline TValueOrError(TValueOrError_ErrorProxy<ArgTypes...>&& Proxy, TIntegerSequence<uint32, ArgIndices...>)
        : Variant(TInPlaceType<FWrapErrorType>(), MoveTemp(Proxy.Args).template Get<ArgIndices>()...)
    {
    }
 
public:
    template <typename... ArgTypes>
    [[nodiscard]] inline TValueOrError(TValueOrError_ValueProxy<ArgTypes...>&& Proxy)
        : TValueOrError(MoveTemp(Proxy), TMakeIntegerSequence<uint32, sizeof...(ArgTypes)>())
    {
    }
 
    template <typename... ArgTypes>
    [[nodiscard]] inline TValueOrError(TValueOrError_ErrorProxy<ArgTypes...>&& Proxy)
        : TValueOrError(MoveTemp(Proxy), TMakeIntegerSequence<uint32, sizeof...(ArgTypes)>())
    {
    }
 
    [[nodiscard]] UE_REWRITE bool IsValid() const
    {
        return Variant.template IsType<ValueType>();
    }
 
    [[nodiscard]] UE_REWRITE bool HasError() const
    {
        return Variant.template IsType<FWrapErrorType>();
    }
 
    [[nodiscard]] inline ErrorType& GetError() & UE_LIFETIMEBOUND
    {
        return Variant.template Get<FWrapErrorType>().Error;
    }
    [[nodiscard]] UE_REWRITE const ErrorType& GetError() const & UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->GetError();
    }
    [[nodiscard]] UE_REWRITE ErrorType&& GetError() && UE_LIFETIMEBOUND
    {
        return MoveTempIfPossible(this->GetError());
    }
 
    [[nodiscard]] inline ErrorType* TryGetError() UE_LIFETIMEBOUND
    {
        if (FWrapErrorType* Wrap = Variant.template TryGet<FWrapErrorType>())
        {
            return &Wrap->Error;
        }
        return nullptr;
    }
    [[nodiscard]] UE_REWRITE const ErrorType* TryGetError() const UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->TryGetError();
    }
 
    [[nodiscard]] inline ErrorType StealError()
    {
        ErrorType Temp = MoveTempIfPossible(GetError());
        Variant.template Emplace<FEmptyType>();
        return Temp;
    }
 
    [[nodiscard]] UE_REWRITE bool HasValue() const
    {
        return Variant.template IsType<ValueType>();
    }
 
    [[nodiscard]] inline ValueType& GetValue() & UE_LIFETIMEBOUND
    {
        return Variant.template Get<ValueType>();
    }
    [[nodiscard]] UE_REWRITE const ValueType& GetValue() const & UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->GetValue();
    }
    [[nodiscard]] UE_REWRITE ValueType&& GetValue() && UE_LIFETIMEBOUND
    {
        return MoveTempIfPossible(this->GetValue());
    }
 
    [[nodiscard]] UE_REWRITE ValueType* TryGetValue() UE_LIFETIMEBOUND
    {
        return Variant.template TryGet<ValueType>();
    }
    [[nodiscard]] UE_REWRITE const ValueType* TryGetValue() const UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->TryGetValue();
    }
 
    [[nodiscard]] inline ValueType StealValue()
    {
        ValueType Temp = MoveTempIfPossible(GetValue());
        Variant.template Emplace<FEmptyType>();
        return Temp;
    }
 
private:
    TVariant<ValueType, FWrapErrorType, FEmptyType> Variant;
};
 
template <typename ValueType>
class TValueOrError<ValueType, void>
{
    static_assert(!std::is_reference_v<ValueType>, "ValueType cannot be a reference");
 
    template <typename... ArgTypes, uint32... ArgIndices>
    [[nodiscard]] inline TValueOrError(TValueOrError_ValueProxy<ArgTypes...>&& Proxy, TIntegerSequence<uint32, ArgIndices...>)
        : Value(InPlace, MoveTemp(Proxy.Args).template Get<ArgIndices>()...)
    {
    }
 
public:
    template <typename... ArgTypes>
    [[nodiscard]] inline TValueOrError(TValueOrError_ValueProxy<ArgTypes...>&& Proxy)
        : TValueOrError(MoveTemp(Proxy), TMakeIntegerSequence<uint32, sizeof...(ArgTypes)>())
    {
    }
 
    [[nodiscard]] inline TValueOrError(TValueOrError_ErrorProxy<>&& Proxy)
    {
    }
 
    [[nodiscard]] UE_REWRITE bool HasError() const
    {
        return !Value.IsSet();
    }
 
    [[nodiscard]] UE_REWRITE bool HasValue() const
    {
        return Value.IsSet();
    }
 
    [[nodiscard]] inline ValueType& GetValue() & UE_LIFETIMEBOUND
    {
        return Value.GetValue();
    }
    [[nodiscard]] UE_REWRITE const ValueType& GetValue() const & UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->GetValue();
    }
    [[nodiscard]] UE_REWRITE ValueType&& GetValue() && UE_LIFETIMEBOUND
    {
        return MoveTempIfPossible(this->GetValue());
    }
 
    [[nodiscard]] inline ValueType* TryGetValue() UE_LIFETIMEBOUND
    {
        return Value.GetPtrOrNull();
    }
    [[nodiscard]] UE_REWRITE const ValueType* TryGetValue() const UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->TryGetValue();
    }
 
    [[nodiscard]] inline ValueType StealValue()
    {
        ValueType Temp = MoveTempIfPossible(GetValue());
        Value.Reset();
        return Temp;
    }
 
private:
    TOptional<ValueType> Value;
};
 
template <typename ErrorType>
class TValueOrError<void, ErrorType>
{
    static_assert(!std::is_reference_v<ErrorType>, "ErrorType cannot be a reference");
 
    template <typename... ArgTypes, uint32... ArgIndices>
    [[nodiscard]] inline TValueOrError(TValueOrError_ErrorProxy<ArgTypes...>&& Proxy, TIntegerSequence<uint32, ArgIndices...>)
        : Error(InPlace, MoveTemp(Proxy.Args).template Get<ArgIndices>()...)
    {
    }
 
public:
    [[nodiscard]] inline TValueOrError(TValueOrError_ValueProxy<>&& Proxy)
    {
    }
 
    template <typename... ArgTypes>
    [[nodiscard]] inline TValueOrError(TValueOrError_ErrorProxy<ArgTypes...>&& Proxy)
        : TValueOrError(MoveTemp(Proxy), TMakeIntegerSequence<uint32, sizeof...(ArgTypes)>())
    {
    }
 
    [[nodiscard]] UE_REWRITE bool HasValue() const
    {
        return !Error.IsSet();
    }
 
    [[nodiscard]] UE_REWRITE bool HasError() const
    {
        return Error.IsSet();
    }
 
    [[nodiscard]] inline ErrorType& GetError() & UE_LIFETIMEBOUND
    {
        return Error.GetValue();
    }
    [[nodiscard]] UE_REWRITE const ErrorType& GetError() const & UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->GetError();
    }
    [[nodiscard]] UE_REWRITE ErrorType&& GetError() && UE_LIFETIMEBOUND
    {
        return MoveTempIfPossible(this->GetError());
    }
 
    [[nodiscard]] inline ErrorType* TryGetError() UE_LIFETIMEBOUND
    {
        return Error.GetPtrOrNull();
    }
    [[nodiscard]] UE_REWRITE const ErrorType* TryGetError() const UE_LIFETIMEBOUND
    {
        return const_cast<TValueOrError*>(this)->TryGetError();
    }
 
    [[nodiscard]] inline ErrorType StealError()
    {
        ErrorType Temp = MoveTempIfPossible(GetError());
        Error.Reset();
        return Temp;
    }
 
private:
    TOptional<ErrorType> Error;
};
 
template <>
class TValueOrError<void, void>
{
public:
    [[nodiscard]] inline TValueOrError(TValueOrError_ValueProxy<>&& Proxy)
        : bValue(true)
    {
    }
 
    [[nodiscard]] inline TValueOrError(TValueOrError_ErrorProxy<>&& Proxy)
        : bValue(false)
    {
    }
 
    [[nodiscard]] UE_REWRITE bool HasError() const
    {
        return !bValue;
    }
 
    [[nodiscard]] UE_REWRITE bool HasValue() const
    {
        return bValue;
    }
 
private:
    bool bValue;
};