DataStream.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "DataStream.generated.h"
 
class UDataStreamManager;
 
namespace UE::Net
{
    class FNetSerializationContext;
    enum class EPacketDeliveryStatus : uint8;
 
    namespace Private
    {
        class FNetExports;
    }
 
 
enum class EDataStreamWriteMode : unsigned
{
    // Allowed to write all data, this is the default WriteMode
    Full,
 
    // Only write data that should be sent after PostTickDispatch
    PostTickDispatch,
};
 
}
 
struct FDataStreamRecord
{
};
 
UENUM()
enum class EDataStreamSendStatus : uint8
{
    Pause = 0,
    Send,
};
 
UCLASS(abstract, MinimalAPI, transient)
class UDataStream : public UObject
{
    GENERATED_BODY()
 
public:
    enum class EWriteResult
    {
        // If NoData is returned then ReadData will not be called on the receiving end.
        NoData,
        // Everything was sent or this stream don't want to send more this frame even if there's more bandwidth.
        Ok, 
        // We have more data to write and can continue to write more if we get another call to write
        HasMoreData,
    };
 
    enum class EUpdateType : uint8
    {
        // Update originating from ReplicationSystem::PreSendUpdate
        PreSendUpdate = 0,
 
        // Update originating from the end of the main Network tick
        PostTickFlush = 1,
    };
 
    enum class EDataStreamState : uint8
    {
        // Stream is invalid
        Invalid = 0,
        // We should send open/init to other side
        PendingCreate, 
        // We are waiting for confirmation that remote have accepted the stream
        WaitOnCreateConfirmation,
        // Stream is open and we will process incoming data.
        Open,
        // We are closing, but still considerd open until flushed
        PendingClose,
        // We have send a close request and is waiting for confirmation before invalidating stream
        WaitOnCloseConfirmation,
 
        Count
    };
 
    struct FInitParameters
    {
    public:
        FInitParameters() = default;
        FInitParameters(UDataStreamManager* InDataStreamManager, const FInitParameters& InParams)
        {
            *this = InParams;
            DataStreamManager = InDataStreamManager;
        }
 
        UE::Net::Private::FNetExports* NetExports = nullptr;
        FName Name;
        uint32 ReplicationSystemId = 0U;
        uint32 ConnectionId = 0U;
        uint32 PacketWindowSize = 0U;
 
    private:
        // We only want this to be accessible from UDataStream base
        UDataStreamManager* DataStreamManager = nullptr;
        friend UDataStream;
    };
 
    struct FBeginWriteParameters
    {
        UE::Net::EDataStreamWriteMode WriteMode = UE::Net::EDataStreamWriteMode::Full;
 
        // Default to sending 1 packet per write. If 0 = unlimited packets
        uint32 MaxPackets = 1U;
    };
 
    struct FUpdateParameters
    {
        EUpdateType UpdateType;
    };
 
public:
    IRISCORE_API virtual ~UDataStream();
 
    IRISCORE_API virtual void Init(const FInitParameters& Params);
 
    IRISCORE_API virtual void Deinit();
 
    IRISCORE_API virtual void Update(const FUpdateParameters& Params);
 
    IRISCORE_API virtual EWriteResult BeginWrite(const FBeginWriteParameters& Params);
 
    virtual EWriteResult WriteData(UE::Net::FNetSerializationContext& Context, FDataStreamRecord const*& OutRecord) PURE_VIRTUAL(WriteData, return EWriteResult::NoData;);
 
    IRISCORE_API virtual void EndWrite();
 
    virtual void ReadData(UE::Net::FNetSerializationContext& Context) PURE_VIRTUAL(ReadData,);
 
    virtual void ProcessPacketDeliveryStatus(UE::Net::EPacketDeliveryStatus Status, FDataStreamRecord const* Record) PURE_VIRTUAL(ProcessPacketDeliveryStatus,);
 
    virtual bool HasAcknowledgedAllReliableData() const PURE_VIRTUAL(HasAcknowledgedAllReliableData, return true;);
 
    FName GetDataStreamName() const
    {
        return DataStreamInitParameters.Name;
    }
 
    IRISCORE_API void RequestClose();
 
    IRISCORE_API const UDataStream::EDataStreamState GetState() const;
 
protected:
    const UDataStream::FInitParameters& GetInitParameters() const
    {
        return DataStreamInitParameters;
    }
 
private:
    FInitParameters DataStreamInitParameters;
};
 
const TCHAR* LexToString(const UDataStream::EDataStreamState State);