TcpSocketBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/OutputDeviceRedirector.h"
#include "SocketSubsystem.h"
#include "Interfaces/IPv4/IPv4Address.h"
#include "Interfaces/IPv4/IPv4Endpoint.h"
#include "Sockets.h"
#include "SocketTypes.h"
 
class Error;
 
class FTcpSocketBuilder
{
public:
 
    FTcpSocketBuilder(const FString& InDescription)
        : Blocking(false)
        , Bound(false)
        , BoundEndpoint(FIPv4Address::Any, 0)
        , Description(InDescription)
        , Linger(false)
        , LingerTimeout(0)
        , Listen(false)
        , ReceiveBufferSize(0)
        , Reusable(false)
        , SendBufferSize(0)
    { }
 
public:
 
    FTcpSocketBuilder AsBlocking()
    {
        Blocking = true;
 
        return *this;
    }
 
    FTcpSocketBuilder AsNonBlocking()
    {
        Blocking = false;
 
        return *this;
    }
 
    FTcpSocketBuilder AsReusable()
    {
        Reusable = true;
 
        return *this;
    }
 
    FTcpSocketBuilder AsReusable(bool bInReusable)
    {
        Reusable = bInReusable;
 
        return *this;
    }
 
    FTcpSocketBuilder BoundToAddress(const FIPv4Address& Address)
    {
        BoundEndpoint = FIPv4Endpoint(Address, BoundEndpoint.Port);
        Bound = true;
 
        return *this;
    }
 
    FTcpSocketBuilder BoundToEndpoint(const FIPv4Endpoint& Endpoint)
    {
        BoundEndpoint = Endpoint;
        Bound = true;
 
        return *this;
    }
 
    FTcpSocketBuilder BoundToPort(uint16 Port)
    {
        BoundEndpoint = FIPv4Endpoint(BoundEndpoint.Address, Port);
        Bound = true;
 
        return *this;
    }
 
    FTcpSocketBuilder Lingering(int32 Timeout)
    {
        Linger = true;
        LingerTimeout = Timeout;
 
        return *this;
    }
 
    FTcpSocketBuilder Listening(int32 MaxBacklog)
    {
        Listen = true;
        ListenBacklog = MaxBacklog;
 
        return *this;
    }
 
    FTcpSocketBuilder WithReceiveBufferSize(int32 SizeInBytes)
    {
        ReceiveBufferSize = SizeInBytes;
 
        return *this;
    }
 
    FTcpSocketBuilder WithSendBufferSize(int32 SizeInBytes)
    {
        SendBufferSize = SizeInBytes;
 
        return *this;
    }
 
public:
 
    operator FSocket*() const
    {
        return Build();
    }
 
    FSocket* Build() const
    {
        FSocket* Socket = nullptr;
 
        ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
 
        if (SocketSubsystem != nullptr)
        {
            TSharedRef<FInternetAddr> BoundEndpointAddr = BoundEndpoint.ToInternetAddr();
            Socket = SocketSubsystem->CreateSocket(NAME_Stream, *Description, BoundEndpointAddr->GetProtocolType());
 
            if (Socket != nullptr)
            {
                bool Error = !Socket->SetReuseAddr(Reusable) ||
                             !Socket->SetLinger(Linger, LingerTimeout) ||
                             !Socket->SetRecvErr();
 
                if (!Error)
                {
                    Error = Bound && !Socket->Bind(*BoundEndpointAddr);
                }
 
                if (!Error)
                {
                    Error = Listen && !Socket->Listen(ListenBacklog);
                }
 
                if (!Error)
                {
                    Error = !Socket->SetNonBlocking(!Blocking);
                }
 
                if (!Error)
                {
                    int32 OutNewSize;
 
                    if (ReceiveBufferSize > 0)
                    {
                        Socket->SetReceiveBufferSize(ReceiveBufferSize, OutNewSize);
                    }
 
                    if (SendBufferSize > 0)
                    {
                        Socket->SetSendBufferSize(SendBufferSize, OutNewSize);
                    }
                }
 
                if (Error)
                {
                    GLog->Logf(TEXT("FTcpSocketBuilder: Failed to create the socket %s as configured"), *Description);
 
                    SocketSubsystem->DestroySocket(Socket);
 
                    Socket = nullptr;
                }
            }
        }
 
        return Socket;
    }
 
private:
 
    bool Blocking;
 
    bool Bound;
 
    FIPv4Endpoint BoundEndpoint;
 
    FString Description;
 
    bool Linger;
 
    int32 LingerTimeout;
 
    bool Listen;
 
    int32 ListenBacklog;
 
    int32 ReceiveBufferSize;
 
    bool Reusable;
 
    int32 SendBufferSize;
};