NetResult.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "Templates/EnableIf.h"
#include "Templates/IsEnum.h"
#include "Templates/PimplPtr.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Class.h"
#include "UObject/ReflectedTypeAccessors.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
 
namespace UE
{
namespace Net
{
 
// Forward declarations
struct FNetResult;
template<typename> struct TNetResult;
 
 
// Expose FNetResult friend functions for Argument Dependent Lookup
template<typename T, typename = typename TEnableIf<TIsEnum<T>::Value>::Type>
TNetResult<T>* Cast(FNetResult* InResult);
 
template<typename T, typename = typename TEnableIf<TIsEnum<T>::Value>::Type>
const TNetResult<T>* Cast(const FNetResult* InResult);
 
 
enum class ENetResultString : uint8
{
    WithoutChain,
 
    WithChain,
 
    ResultEnumOnly
};
 
namespace Private
{
    NETCORE_API void NetResultToString(FString& OutResultStr, const TCHAR* LexResult, const FString& ErrorContext,
                                                ENetResultString ConversionType);
}
 
 
struct FNetResult
{
    template<typename> friend struct TNetResult;
 
private:
    inline FNetResult(uint64 InResult, const UEnum* InResultEnumObj)
        : Result(InResult)
        , ResultEnumObj(InResultEnumObj)
        , RawResultEnumObj(InResultEnumObj)
    {
    }
 
    inline FNetResult(uint64 InResult, const UEnum* InResultEnumObj, const FString& InErrorContext)
        : Result(InResult)
        , ResultEnumObj(InResultEnumObj)
        , RawResultEnumObj(InResultEnumObj)
        , ErrorContext(InErrorContext)
    {
    }
 
    inline FNetResult(uint64 InResult, const UEnum* InResultEnumObj, FString&& InErrorContext)
        : Result(InResult)
        , ResultEnumObj(InResultEnumObj)
        , RawResultEnumObj(InResultEnumObj)
        , ErrorContext(MoveTemp(InErrorContext))
    {
    }
 
public:
    FNetResult(const FNetResult&) = default;
    FNetResult& operator=(const FNetResult&) = default;
    FNetResult(FNetResult&&) = default;
    FNetResult& operator=(FNetResult&&) = default;
    ~FNetResult() = default;
 
 
    bool operator == (const FNetResult& A) const
    {
        return Result == A.Result && ErrorContext == A.ErrorContext && RawResultEnumObj == A.RawResultEnumObj &&
            NextResult.IsValid() == A.NextResult.IsValid() && (!NextResult.IsValid() || *NextResult == *A.NextResult);
    }
 
    bool operator != (const FNetResult& A) const
    {
        return !(FNetResult::operator == (A));
    }
 
 
    template<typename T, typename>
    friend TNetResult<T>* Cast(FNetResult* InResult)
    {
        TNetResult<T>* ReturnVal = nullptr;
 
        if (InResult != nullptr && InResult->RawResultEnumObj == StaticEnum<T>())
        {
            ReturnVal = static_cast<TNetResult<T>*>(InResult);
        }
 
        return ReturnVal;
    }
 
    template<typename T, typename>
    friend const TNetResult<T>* Cast(const FNetResult* InResult)
    {
        const TNetResult<T>* ReturnVal = nullptr;
 
        if (InResult != nullptr && InResult->RawResultEnumObj == StaticEnum<T>())
        {
            ReturnVal = static_cast<const TNetResult<T>*>(InResult);
        }
 
        return ReturnVal;
    }
 
 
    NETCORE_API FString DynamicToString(ENetResultString ConversionType=ENetResultString::WithoutChain) const;
 
    friend uint32 GetTypeHash(FNetResult const& Hash)
    {
        return HashCombine(::GetTypeHash((uint64)Hash.Result), ::GetTypeHash(Hash.RawResultEnumObj));
    }
 
 
    void AddChainResult(FNetResult&& InResult)
    {
        FNetResult* ChainEnd = this;
 
        // Not intended to be fast, just in a useful order while using less members
        while (ChainEnd->NextResult.IsValid())
        {
            ChainEnd = ChainEnd->NextResult.Get();
        }
 
        ChainEnd->NextResult = MakePimpl<FNetResult, EPimplPtrMode::DeepCopy>(MoveTemp(InResult));
    }
 
    template<typename T, typename = typename TEnableIf<TIsEnum<T>::Value>::Type>
    void AddChainResult(TNetResult<T>&& InResult)
    {
        FNetResult* ChainEnd = this;
 
        // Not intended to be fast, just in a useful order while using less members
        while (ChainEnd->NextResult.IsValid())
        {
            ChainEnd = ChainEnd->NextResult.Get();
        }
 
        ChainEnd->NextResult = MakePimpl<FNetResult, EPimplPtrMode::DeepCopy>(MoveTemp(InResult));
    }
 
    template<typename ResultEnum, typename = typename TEnableIf<TIsEnum<ResultEnum>::Value>::Type>
    bool HasChainResult(ResultEnum A) const
    {
        for (FConstIterator It(*this); It; ++It)
        {
            const TNetResult<ResultEnum>* CurResult = Cast<ResultEnum>(&*It);
 
            if (CurResult != nullptr && static_cast<ResultEnum>(CurResult->Result) == A)
            {
                return true;
            }
        }
 
        return false;
    }
 
 
public:
    struct FConstIterator final
    {
        FConstIterator(const FNetResult& InResult)
            : CurResult(&InResult)
        {
        }
 
        explicit operator bool() const
        {
            return CurResult != nullptr;
        }
 
        const FNetResult& operator *() const
        {
            check(CurResult != nullptr);
 
            return *CurResult;
        }
 
        const FNetResult* operator ->() const
        {
            return CurResult;
        }
 
        void operator ++()
        {
            if (CurResult != nullptr)
            {
                CurResult = CurResult->NextResult.Get();
            }
        }
 
    private:
        const FNetResult* CurResult;
    };
 
 
private:
    uint64 Result   = 0;
 
    TWeakObjectPtr<const UEnum> ResultEnumObj;
 
    const void* RawResultEnumObj = nullptr;
 
    FString ErrorContext;
 
    TPimplPtr<FNetResult, EPimplPtrMode::DeepCopy> NextResult;
};
 
inline void AddToChainResultPtr(TPimplPtr<FNetResult, EPimplPtrMode::DeepCopy>& ResultPtr, FNetResult&& Result)
{
    if (ResultPtr.IsValid())
    {
        ResultPtr->AddChainResult(MoveTemp(Result));
    }
    else
    {
        ResultPtr = MakePimpl<FNetResult, EPimplPtrMode::DeepCopy>(MoveTemp(Result));
    }
}
 
inline FNetResult AddToAndConsumeChainResultPtr(TPimplPtr<FNetResult, EPimplPtrMode::DeepCopy>& ResultPtr, FNetResult&& Result)
{
    const bool bValidResultPtr = ResultPtr.IsValid();
    FNetResult ReturnVal(bValidResultPtr ? MoveTemp(*ResultPtr) : MoveTemp(Result));
 
    if (bValidResultPtr)
    {
        ReturnVal.AddChainResult(MoveTemp(Result));
    }
 
    return ReturnVal;
}
 
 
template<typename ResultEnum>
struct TNetResult final : public FNetResult
{
    static_assert(TIsEnum<ResultEnum>::Value, "ResultEnum must be an enum");
    static_assert(ResultEnum::Success != ResultEnum::Unknown, "ResultEnum must contain a 'Success' and 'Unknown' (i.e. undetermined) value");
 
    using UnderlyingResultType = __underlying_type(ResultEnum);
 
public:
    TNetResult(ResultEnum InResult=ResultEnum::Unknown)
        : FNetResult(static_cast<UnderlyingResultType>(InResult), StaticEnum<ResultEnum>())
    {
        if (InResult != ResultEnum::Unknown && InResult != ResultEnum::Success)
        {
            ErrorContext = DefaultErrorContext(InResult);
        }
    }
 
    TNetResult(ResultEnum InResult, const FString& InErrorContext)
        : FNetResult(static_cast<UnderlyingResultType>(InResult), StaticEnum<ResultEnum>())
    {
        if (InResult != ResultEnum::Unknown && InResult != ResultEnum::Success)
        {
            ErrorContext = (InErrorContext.IsEmpty() ? DefaultErrorContext(InResult) : InErrorContext);
        }
    }
 
 
    FString ToString(ENetResultString ConversionType=ENetResultString::WithoutChain) const
    {
        using namespace UE::Net::Private;
 
        FString ReturnVal;
        const bool bIncludeChain = ConversionType == ENetResultString::WithChain;
 
        for (FConstIterator It(*this); It; ++It)
        {
            const TCHAR* ResultLex = ToCStr(LexToString(static_cast<ResultEnum>(It->Result)));
 
            if (ConversionType == ENetResultString::ResultEnumOnly)
            {
                ReturnVal = ResultLex;
            }
            else
            {
                NetResultToString(ReturnVal, ResultLex, It->ErrorContext, ConversionType);
            }
 
            if (!bIncludeChain)
            {
                break;
            }
        }
 
        return ReturnVal;
    }
 
 
    bool WasSuccessful() const
    {
        return static_cast<ResultEnum>(Result) == ResultEnum::Success;
    }
 
    ResultEnum GetResult() const
    {
        return static_cast<ResultEnum>(Result);
    }
 
    const FString& GetErrorContext() const
    {
        return ErrorContext;
    }
 
 
    bool HasChainResult(const TNetResult& A) const
    {
        for (FConstIterator It(*this); It; ++It)
        {
            if (*It == A)
            {
                return true;
            }
        }
 
        return false;
    }
 
 
    bool operator == (ResultEnum A) const
    {
        return static_cast<ResultEnum>(Result) == A;
    }
 
    bool operator != (ResultEnum A) const
    {
        return !(TNetResult::operator == (A));
    }
 
private:
    static const TCHAR* DefaultErrorContext(ResultEnum InResult)
    {
        return (InResult == ResultEnum::Success ? TEXT("") : ToCStr(LexToString(InResult)));
    }
};
 
#define DECLARE_NETRESULT_ENUM(EnumType) \
    namespace UE \
    { \
    namespace Net \
    { \
        inline void AddToChainResultPtr(TPimplPtr<FNetResult, EPimplPtrMode::DeepCopy>& ResultPtr, TNetResult<EnumType>&& Result) { AddToChainResultPtr(ResultPtr, static_cast<FNetResult&&>(Result)); } \
        inline FNetResult AddToAndConsumeChainResultPtr(TPimplPtr<FNetResult, EPimplPtrMode::DeepCopy>& ResultPtr, TNetResult<EnumType>&& Result) { return AddToAndConsumeChainResultPtr(ResultPtr, static_cast<FNetResult&&>(Result)); } \
    } \
    }
 
}
}