IMessageRpcClient.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "MessageEndpoint.h"
#include "Misc/Guid.h"
#include "IMessageContext.h"
#include "IMessageRpcCall.h"
#include "Async/IAsyncProgress.h"
#include "Async/IAsyncTask.h"
#include "Async/Future.h"
#include "Async/AsyncResult.h"
 
class IMessageRpcClient
{
    class FCall
        : public IAsyncProgress
        , public IAsyncTask
        , public IMessageRpcCall
    {
    public:
 
        FCall()
            : State(EAsyncTaskState::Running)
            , TimeCreated(FDateTime::UtcNow())
        { }
 
    public:
 
        FSimpleDelegate& OnCancelled()
        {
            return CanceledDelegate;
        }
 
    public:
 
        virtual TOptional<float> GetCompletion() override
        {
            return Completion;
        }
 
        virtual FText GetStatusText() override
        {
            return StatusText;
        }
 
        virtual FSimpleDelegate& OnProgressChanged() override
        {
            return ProgressChangedDelegate;
        }
 
    public:
 
        virtual void Cancel() override
        {
            State = EAsyncTaskState::Cancelled;
            CanceledDelegate.ExecuteIfBound();
        }
 
        virtual EAsyncTaskState GetTaskState() override
        {
            return State;
        }
 
    public:
 
        virtual FDateTime GetLastUpdated() const override
        {
            return LastUpdated;
        }
 
        virtual FDateTime GetTimeCreated() const override
        {
            return TimeCreated;
        }
 
        virtual void UpdateProgress(float InCompletion, const FText& InStatusText) override
        {
            Completion = InCompletion;
            StatusText = InStatusText;
            LastUpdated = FDateTime::UtcNow();
 
            ProgressChangedDelegate.ExecuteIfBound();
        }
 
    protected:
 
        float Completion;
        FDateTime LastUpdated;
        EAsyncTaskState State;
        FText StatusText;
        FDateTime TimeCreated;
 
    private:
 
        FSimpleDelegate CanceledDelegate;
        FSimpleDelegate ProgressChangedDelegate;
    };
 
 
    template<typename RpcType, typename... P>
    class TCall
        : public FCall
    {
    public:
 
        TCall(const FGuid& CallId, P... Params)
            : MessageTemplate(new typename RpcType::FRequest(Params...))
        {
            MessageTemplate->CallId = CallId;
        }
 
        virtual ~TCall()
        {
            delete MessageTemplate;
        }
 
        virtual void Complete(const TSharedRef<IMessageContext, ESPMode::ThreadSafe>& ResponseContext) override
        {
            if (ResponseContext->GetMessageTypeInfo() == RpcType::FResponse::StaticStruct())
            {
                State = EAsyncTaskState::Completed;
                Promise.SetValue(static_cast<const typename RpcType::FResponse*>(ResponseContext->GetMessage())->Result);
            }
            else
            {
                State = EAsyncTaskState::Failed;
                Promise.SetValue(typename RpcType::FResult());
            }
        }
 
        virtual void* ConstructMessage() const override
        {
            return FMessageEndpoint::MakeMessage<typename RpcType::FRequest>(*MessageTemplate);
        }
 
        TFuture<typename RpcType::FResult> GetFuture()
        {
            return Promise.GetFuture();
        }
 
        virtual const FGuid& GetId() const override
        {
            return MessageTemplate->CallId;
        }
 
        virtual void* GetMessageTemplate() const override
        {
            return MessageTemplate;
        }
 
        virtual UScriptStruct* GetMessageType() const override
        {
            return RpcType::FRequest::StaticStruct();
        }
 
        virtual void TimeOut() override
        {
            State = EAsyncTaskState::Failed;
            Promise.SetValue(typename RpcType::FResult());
        }
 
    private:
 
        TPromise<typename RpcType::FResult> Promise;
        typename RpcType::FRequest* MessageTemplate;
    };
 
public:
 
    virtual void Connect(const FMessageAddress& InServerAddress) = 0;
 
    virtual void Disconnect() = 0;
 
    virtual bool IsConnected() const = 0;
 
public:
 
    template<typename RpcType, typename... P>
    TAsyncResult<typename RpcType::FResult> Call(P... Params)
    {
        typedef TCall<RpcType, P...> CallType;
 
        FGuid CallId = FGuid::NewGuid();
        TSharedRef<CallType> Call = MakeShareable(new CallType(CallId, Params...));
        {
            AddCall(Call);
 
            Call->OnCancelled().BindLambda([this, CallId]() {
                CancelCall(CallId);
            }); 
        }
 
        return TAsyncResult<typename RpcType::FResult>(Call->GetFuture(), Call, Call);
    }
 
protected:
 
    virtual void AddCall(const TSharedRef<IMessageRpcCall>& Call) = 0;
 
    virtual void CancelCall(const FGuid& CallId) = 0;
 
public:
 
    virtual ~IMessageRpcClient() { }
};
 
 
Expose_TNameOf(IMessageRpcClient)