NetTokenStore.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Net/Core/NetToken/NetToken.h"
#include "UObject/NameTypes.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Templates/Tuple.h"
 
#include "NetTokenStore.generated.h"
 
/* NetBitArray validation support. */
#ifndef UE_NET_VALIDATE_NETTOKENTYPE
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
#   define UE_NET_VALIDATE_NETTOKENTYPE 0
#else
#   define UE_NET_VALIDATE_NETTOKENTYPE 1
#endif
#endif
 
 
class UNetTokenDataStream;
namespace UE::Net
{
    class FNetTokenDataStore;
    class FNetTokenStore;
    class FNetTokenStoreState;
    class FNetSerializationContext;
 
    namespace Private
    {
        class FNetExportContext;
    }
}
 
USTRUCT()
struct FNetTokenStoreTypeIdPair
{
    GENERATED_BODY()
    UPROPERTY()
    FString StoreTypeName;
    UPROPERTY()
    uint32 TypeID = 0;
    bool operator<(const FNetTokenStoreTypeIdPair& Other) const
    {
        return TypeID < Other.TypeID;
    }
};
    
UCLASS(Transient, MinimalAPI, config=Engine)
class UNetTokenTypeIdConfig : public UObject
{
    GENERATED_BODY()
 
public:
    UPROPERTY(Config)
    TArray<FNetTokenStoreTypeIdPair> ReservedTypeIds;
 
    uint32 GetTypeID(const FString& TypeName) const;
    uint32 GetTypeID(const FName& TypeName) const
    {
        return GetTypeID(TypeName.ToString());
    }
    
protected:
    bool ReservedTypeIdsAppearValid() const;
};
 
namespace UE::Net
{
class FNetTokenDataStore
{
public:
    class FNetTokenStoreKey
    {
    public:
        enum { InvalidKeyIndex = 0U };
 
        FNetTokenStoreKey()
        : KeyIndex(InvalidKeyIndex)
        {
        }
 
        explicit FNetTokenStoreKey(uint32 InKeyIndex)
        : KeyIndex(InKeyIndex)
        {
        }
 
        uint32 GetKeyIndex() const
        { 
            return KeyIndex;
        }
 
        bool IsValid() const
        { 
            return KeyIndex != InvalidKeyIndex;
        }
 
        bool operator==(const FNetTokenStoreKey& Other) const = default;
 
    private:
        uint32 KeyIndex = InvalidKeyIndex;
    };
 
    IRISCORE_API virtual ~FNetTokenDataStore();
 
    // Serialization methods for NetTokens that does not include the TypeId as this is known by the NetTokenDataStore.
 
    // Write NetToken
    IRISCORE_API void WriteNetToken(UE::Net::FNetSerializationContext& Context, FNetToken Token);
 
    // Read NetToken
    IRISCORE_API FNetToken ReadNetToken(UE::Net::FNetSerializationContext& Context);
 
    // Write NetToken
    IRISCORE_API void WriteNetToken(FArchive& Ar, FNetToken Token);
 
    // Read NetToken
    IRISCORE_API FNetToken ReadNetToken(FArchive& Ar);
 
protected:
 
    explicit IRISCORE_API FNetTokenDataStore(FNetTokenStore& InTokenStore);
 
    virtual void WriteTokenData(FNetSerializationContext& Context, FNetTokenStoreKey Key) const = 0;
    virtual FNetTokenDataStore::FNetTokenStoreKey ReadTokenData(FNetSerializationContext& Context, const FNetToken& NetToken) = 0;
 
    //Do not export things through the UPackageMap. This will break things.
    virtual void WriteTokenData(FArchive& Ar, FNetTokenStoreKey Key, UPackageMap* Map = nullptr) const = 0;
    virtual FNetTokenDataStore::FNetTokenStoreKey ReadTokenData(FArchive& Ar, const FNetToken& NetToken, UPackageMap* Map = nullptr) = 0;
    
    IRISCORE_API FNetTokenDataStore::FNetTokenStoreKey GetTokenKey(FNetToken Token, const FNetTokenStoreState& TokenStoreState) const;
 
    inline FNetToken::FTypeId GetTypeId() const
    {
        return TypeId;
    }
 
    // Create new NetToken
    IRISCORE_API FNetToken CreateAndStoreTokenForKey(FNetTokenStoreKey Key);
    IRISCORE_API void StoreTokenForKey(FNetTokenStoreKey Key, FNetToken NetToken);
    IRISCORE_API FNetToken GetNetTokenFromKey(FNetTokenStoreKey) const;
 
    // Allocate next TokenStoreKey
    FNetTokenDataStore::FNetTokenStoreKey GetNextNetTokenStoreKey();
 
protected:
    // Maps from FNetTokenStoreKey (index) to NetToken, this typically is the locally assigned NetToken, but can be overridden if we receive a token from the authority.
    TArray<FNetToken> StoredTokens;
    FNetTokenStore& TokenStore;
 
private:
    friend FNetTokenStore;
    FNetToken::FTypeId TypeId;
};
 
class FNetTokenStore
{
    UE_NONCOPYABLE(FNetTokenStore);
public:
    IRISCORE_API FNetTokenStore();
    IRISCORE_API ~FNetTokenStore();
 
    struct FInitParams
    {
        FNetToken::ENetTokenAuthority Authority;
        uint32 MaxConnections = 256;
    };
    IRISCORE_API void Init(FInitParams& InitParams);
 
    bool IsAuthority() const
    {
        return Params.Authority == FNetToken::ENetTokenAuthority::Authority;
    }
 
    bool IsLocalToken(const FNetToken NetToken) const
    {
        return !NetToken.IsValid() || IsAuthority() == NetToken.IsAssignedByAuthority();
    }
 
    IRISCORE_API bool RegisterDataStore(TUniquePtr<FNetTokenDataStore> DataStore, FName TokenStoreName);
 
    IRISCORE_API bool UnRegisterDataStore(FName TokenStoreName);
 
    IRISCORE_API const FNetTokenDataStore* GetDataStore(FName Name) const;
 
    IRISCORE_API FNetTokenDataStore* GetDataStore(FName Name);
 
    template<typename T>
    bool CreateAndRegisterDataStore()
    {
        TUniquePtr<FNetTokenDataStore> NetTokenDataStore(MakeUnique<T>(*this));
        
        return RegisterDataStore(MakeUnique<T>(*this), T::GetTokenStoreName());
    }
    
    template<typename T>
    bool DeleteAndUnRegisterDataStore()
    {
        return UnRegisterDataStore(T::GetTokenStoreName());
    }
 
    template<typename T>
    T* GetDataStore()
    {
        return static_cast<T*>(GetDataStore(T::GetTokenStoreName()));
    }
 
    template<typename T>
    const T* GetDataStore() const
    {
        return static_cast<const T*>(GetDataStore(T::GetTokenStoreName()));
    }
    
    // FNetTokenStoreState maps from NetTokenIndex -> NetTokenStoreKey (Index)
    // Remote and local NetTokens use separate NetTokensStore states.
 
    const FNetTokenStoreState* GetLocalNetTokenStoreState() const
    {
        return LocalNetTokenStoreState.Get();
    }
 
    FNetTokenStoreState* GetLocalNetTokenStoreState()
    {
        return LocalNetTokenStoreState.Get();
    }
 
    IRISCORE_API void InitRemoteNetTokenStoreState(uint32 ConnectionId);
 
    IRISCORE_API const FNetTokenStoreState* GetRemoteNetTokenStoreState(uint32 ConnectionId) const;
 
    IRISCORE_API FNetTokenStoreState* GetRemoteNetTokenStoreState(uint32 ConnectionId);
 
    IRISCORE_API void WriteTokenData(FNetSerializationContext& Context, const FNetToken NetToken) const;
 
    IRISCORE_API void ReadTokenData(FNetSerializationContext& Context, const FNetToken NetToken, FNetTokenStoreState& RemoteNetTokenStoreState);
 
    IRISCORE_API void WriteTokenData(FArchive& Ar, const FNetToken NetToken, UPackageMap* Map = nullptr) const;
    
    IRISCORE_API void ReadTokenData(FArchive& Ar, const FNetToken NetToken, FNetTokenStoreState& RemoteNetTokenStoreState, UPackageMap* Map = nullptr);
 
    IRISCORE_API void ConditionalWriteNetTokenData(FNetSerializationContext& Context, Private::FNetExportContext* ExportContext, const FNetToken NetToken) const;
 
    IRISCORE_API void ConditionalReadNetTokenData(FNetSerializationContext& Context, const FNetToken NetToken);
 
    IRISCORE_API static void AppendExport(FNetSerializationContext&, FNetToken NetToken);
 
    template <typename T>
    void WriteNetTokenWithKnownType(FNetSerializationContext& Context, FNetToken NetToken)
    {
#if UE_NET_VALIDATE_NETTOKENTYPE
        // We only verify this in dev builds as it should trap most programmer errors.
        if (NetToken.IsValid())
        {
            const T* DataStore = GetDataStore<T>();
            if (!DataStore || (DataStore->GetTypeId() != NetToken.GetTypeId()))
            {
                UE_LOG(LogNetToken, Error, TEXT("Tried to write NetToken %s using invalid NetTokenStore %s"), *NetToken.ToString(), *(T::GetTokenStoreName().ToString()));
                // Just to get some attention to the log.
                ensure(DataStore && (DataStore->GetTypeId() == NetToken.GetTypeId()));
            }
        }
#endif
        const bool bWriteTypeId = false;
        FNetTokenStore::InternalWriteNetToken(Context, NetToken, bWriteTypeId);
    }
 
    template <typename T>
    FNetToken ReadNetTokenWithKnownType(FNetSerializationContext& Context)
    {
        FNetToken NetToken;
        if (T* DataStore = GetDataStore<T>())
        {
            NetToken = DataStore->ReadNetToken(Context);
        }
        else
        {
            UE_LOG(LogNetToken, Error, TEXT("ReadNetTokenWithKnownType Tried to read NetToken using invalid NetTokenStore %s"), *(T::GetTokenStoreName().ToString()));
            // Just to get some attention to the log.
            ensure(DataStore);
        }
 
        return NetToken;
    }
 
    void WriteNetToken(FNetSerializationContext& Context, FNetToken NetToken) const
    {
        const bool bWriteTypeId = true;
        FNetTokenStore::InternalWriteNetToken(Context, NetToken, bWriteTypeId);
    }
 
    FNetToken ReadNetToken(FNetSerializationContext& Context) const
    {
        return InternalReadNetToken(Context, FNetToken::InvalidTokenTypeId);
    }
 
    void WriteNetToken(FArchive& Ar, FNetToken NetToken) const
    {
        const bool bWriteTypeId = true;
        FNetTokenStore::InternalWriteNetToken(Ar, NetToken, bWriteTypeId);
    }
 
    FNetToken ReadNetToken(FArchive& Ar) const
    {
        return InternalReadNetToken(Ar, FNetToken::InvalidTokenTypeId);
    }
    
private:
 
    friend UNetTokenDataStream;
    friend FNetTokenDataStore;
 
    using FNetTokenStoreKey = FNetTokenDataStore::FNetTokenStoreKey;
 
    // Internal method to write a NetToken, if bWriteTokenType is true it will write the TypeId as well.
    IRISCORE_API static void InternalWriteNetToken(UE::Net::FNetSerializationContext& Context, FNetToken Token, bool bWriteTokenType);
    IRISCORE_API static void InternalWriteNetToken(FArchive& Ar, FNetToken Token, bool bWriteTokenType);
 
    // Internal method to read a NetToken, if the TokenTypeId is valid it will be used instead of reading it from the bitstream
    IRISCORE_API static FNetToken InternalReadNetToken(UE::Net::FNetSerializationContext& Context, FNetToken::FTypeId TokenTypeId);
    IRISCORE_API static FNetToken InternalReadNetToken(FArchive& Ar, FNetToken::FTypeId TokenTypeId);
 
    bool ValidateAndStoreNetTokenData(FNetTokenDataStore& DataStore, FNetTokenStoreState& RemoteNetTokenStoreState, const FNetToken NetToken, const FNetTokenStoreKey StoreKey);
    
    TArray<FNetToken> GetAllNetTokens() const;
 
    static FNetToken MakeNetToken(uint32 TypeId, uint32 Index, FNetToken::ENetTokenAuthority Authority)
    { 
        if ((TypeId < FNetToken::MaxTypeIdCount) && (Index < FNetToken::MaxNetTokenCount))
        {
            return FNetToken(TypeId, Index, Authority);
        }
        
        return FNetToken();
    }
 
    TUniquePtr<FNetTokenStoreState> LocalNetTokenStoreState;
    TArray<TUniquePtr<FNetTokenStoreState>> RemoteNetTokenStoreStates;
    TArray<TTuple<FName, TUniquePtr<FNetTokenDataStore>>> TokenDataStores;
    FInitParams Params;
};
 
inline FNetTokenDataStore::FNetTokenStoreKey FNetTokenDataStore::GetNextNetTokenStoreKey()
{
    uint32 NextTokenStoreKeyIndex = (uint32)StoredTokens.Num();
    if (ensure(NextTokenStoreKeyIndex < FNetToken::MaxNetTokenCount))
    {
        FNetTokenStoreKey TokenKey(NextTokenStoreKeyIndex);
 
        // We fill in the actual key later
        StoredTokens.Add(FNetToken());
 
        return TokenKey;
    }
 
    return FNetTokenStoreKey();
}
}