IMessageRpcServer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "IMessageContext.h"
#include "MessageEndpoint.h"
#include "Async/IAsyncTask.h"
#include "Async/AsyncResult.h"
#include "IMessageRpcHandler.h"
#include "IMessageRpcReturn.h"
 
struct FRpcMessage;
 
template<typename ResultType> class TFuture;
 
UE_DEPRECATED(5.1, "Types names are now represented by path names. Please use FOnMessagePathNameRpcNoHandler.")
DECLARE_DELEGATE_OneParam(FOnMessageRpcNoHandler, const FName& /*MessageType*/)
 
DECLARE_DELEGATE_OneParam(FOnMessagePathNameRpcNoHandler, const FTopLevelAssetPath& /*MessageType*/)
 
class IMessageRpcServer
{
    template<typename RpcType>
    class TReturn
        : public IMessageRpcReturn
    {
    public:
 
        TReturn(TAsyncResult<typename RpcType::FResult>&& InResult)
            : Result(MoveTemp(InResult))
        { }
 
        virtual void Cancel() override
        {
            auto Task = Result.GetTask();
 
            if (Task.IsValid())
            {
                Task->Cancel();
            }
        }
 
        virtual FRpcMessage* CreateResponseMessage() const override
        {
            const TFuture<typename RpcType::FResult>& Future = Result.GetFuture();
            check(Future.IsReady());
 
            return FMessageEndpoint::MakeMessage<typename RpcType::FResponse>(Future.Get());
        }
 
        virtual UScriptStruct* GetResponseTypeInfo() const override
        {
            return RpcType::FResponse::StaticStruct();
        }
 
        virtual bool IsReady() const override
        {
            return Result.GetFuture().IsReady();
        }
 
        TAsyncResult<typename RpcType::FResult> Result;
    };
 
 
    template<typename RpcType, typename HandlerType>
    class THandler
        : public IMessageRpcHandler
    {
    public:
 
        typedef TAsyncResult<typename RpcType::FResult>(HandlerType::*FuncType)(const typename RpcType::FRequest&);
 
        THandler( HandlerType* InHandler, FuncType InFunc )
            : Handler(InHandler)
            , Func(InFunc)
        {
            check(InHandler != nullptr);
        }
 
        virtual TSharedRef<IMessageRpcReturn> HandleRequest(const TSharedRef<IMessageContext, ESPMode::ThreadSafe>& Context) override
        {
            return MakeShareable(new TReturn<RpcType>((Handler->*Func)(*static_cast<const typename RpcType::FRequest*>(Context->GetMessage()))));
        }
    
    private:
 
        HandlerType* Handler;
        FuncType Func;
    };
 
public:
 
    UE_DEPRECATED(5.1, "Types names are now represented by path names. Please use a version of this function that takes an FTopLevelAssetPath as MessageType.")
    inline void AddHandler(const FName& RequestMessageType, const TSharedRef<IMessageRpcHandler>& Handler)
    {
        AddHandler(UClass::TryConvertShortTypeNameToPathName<UStruct>(RequestMessageType.ToString()), Handler);
    }
 
    virtual void AddHandler(const FTopLevelAssetPath& RequestMessageType, const TSharedRef<IMessageRpcHandler>& Handler) = 0;
 
    virtual const FMessageAddress& GetAddress() const = 0;
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.1, "Types names are now represented by path names. Please use OnNoHandlerWithPathName.")    
    virtual FOnMessageRpcNoHandler& OnNoHandler() = 0;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    virtual FOnMessagePathNameRpcNoHandler& OnNoHandlerWithPathName() = 0;
 
    virtual void SetSendProgressUpdate(bool InSendProgress) = 0;
 
public:
 
    template<typename RpcType, typename HandlerType>
    void RegisterHandler(HandlerType* Handler, typename THandler<RpcType, HandlerType>::FuncType Func)
    {
        AddHandler(RpcType::FRequest::StaticStruct()->GetFName(), MakeShareable(new THandler<RpcType, HandlerType>(Handler, Func)));
    }
 
public:
 
    virtual ~IMessageRpcServer() { }
};