MessageEndpointBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Async/TaskGraphInterfaces.h"
#include "IMessageBus.h"
#include "IMessageHandler.h"
#include "IMessagingModule.h"
#include "MessageEndpoint.h"
#include "MessageHandlers.h"
 
 
struct FMessageEndpointBuilder
{
public:
 
    FMessageEndpointBuilder(const FName& InName)
        : BusPtr(IMessagingModule::Get().GetDefaultBus())
        , Disabled(false)
        , InboxEnabled(false)
        , Name(InName)
        , RecipientThread(FTaskGraphInterface::Get().GetCurrentThreadIfKnown())
    { }
 
    FMessageEndpointBuilder(const FName& InName, const TSharedRef<IMessageBus, ESPMode::ThreadSafe>& InBus)
        : BusPtr(InBus)
        , Disabled(false)
        , InboxEnabled(false)
        , Name(InName)
        , RecipientThread(FTaskGraphInterface::Get().GetCurrentThreadIfKnown())
    { }
 
public:
 
    template<typename MessageType, typename HandlerType>
    FMessageEndpointBuilder& Handling(HandlerType* Handler, typename TRawMessageHandler<MessageType, HandlerType>::FuncType HandlerFunc)
    {
        Handlers.Add(MakeShareable(new TRawMessageHandler<MessageType, HandlerType>(Handler, MoveTemp(HandlerFunc))));
 
        return *this;
    }
 
    template<typename MessageType>
    FMessageEndpointBuilder& Handling(typename TFunctionMessageHandler<MessageType>::FuncType HandlerFunc)
    {
        Handlers.Add(MakeShareable(new TFunctionMessageHandler<MessageType>(MoveTemp(HandlerFunc))));
 
        return *this;
    }
 
    FMessageEndpointBuilder& NotificationHandling(FOnBusNotification&& InHandler)
    {
        OnNotification = MoveTemp(InHandler);
        return *this;
    }
 
    FMessageEndpointBuilder& ReceivingOnAnyThread()
    {
        RecipientThread = ENamedThreads::AnyThread;
 
        return *this;
    }
 
    FMessageEndpointBuilder& ReceivingOnThread(ENamedThreads::Type NamedThread)
    {
        RecipientThread = NamedThread;
 
        return *this;
    }
 
    FMessageEndpointBuilder& ThatIsDisabled()
    {
        Disabled = true;
 
        return *this;
    }
 
    template<typename HandlerType>
    FMessageEndpointBuilder& WithCatchall(HandlerType* Handler, typename TRawMessageCatchall<HandlerType>::FuncType HandlerFunc)
    {
        Handlers.Add(MakeShareable(new TRawMessageCatchall<HandlerType>(Handler, MoveTemp(HandlerFunc))));
 
        return *this;
    }
 
    FMessageEndpointBuilder& WithCatchall(FFunctionMessageCatchall::FuncType HandlerFunc)
    {
        Handlers.Add(MakeShareable(new FFunctionMessageCatchall(MoveTemp(HandlerFunc))));
 
        return *this;
    }
 
    FMessageEndpointBuilder& WithHandler(const TSharedRef<IMessageHandler, ESPMode::ThreadSafe>& Handler)
    {
        Handlers.Add(Handler);
 
        return *this;
    }
 
    FMessageEndpointBuilder& WithInbox()
    {
        InboxEnabled = true;
 
        return *this;
    }
 
public:
 
    TSharedPtr<FMessageEndpoint, ESPMode::ThreadSafe> Build()
    {
        TSharedPtr<FMessageEndpoint, ESPMode::ThreadSafe> Endpoint;
        TSharedPtr<IMessageBus, ESPMode::ThreadSafe> Bus = BusPtr.Pin();
        
        if (Bus.IsValid())
        {
            Endpoint = MakeShared<FMessageEndpoint, ESPMode::ThreadSafe>(Name, Bus.ToSharedRef(), Handlers, OnNotification);
            Bus->Register(Endpoint->GetAddress(), Endpoint.ToSharedRef());
 
            if (OnNotification.IsBound())
            {
                Bus->AddNotificationListener(Endpoint.ToSharedRef());
            }
 
            if (Disabled)
            {
                Endpoint->Disable();
            }
 
            if (InboxEnabled)
            {
                Endpoint->EnableInbox();
                Endpoint->SetRecipientThread(ENamedThreads::AnyThread);
            }
            else
            {
                Endpoint->SetRecipientThread(RecipientThread);
            }
        }
 
        return Endpoint;
    }
 
    operator TSharedPtr<FMessageEndpoint, ESPMode::ThreadSafe>()
    {
        return Build();
    }
    
private:
 
    TWeakPtr<IMessageBus, ESPMode::ThreadSafe> BusPtr;
 
    bool Disabled;
 
    FOnBusNotification OnNotification;
 
    TArray<TSharedPtr<IMessageHandler, ESPMode::ThreadSafe>> Handlers;
 
    bool InboxEnabled;
 
    FName Name;
 
    ENamedThreads::Type RecipientThread;
};