NetDormantHolder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectKey.h"
#include "Templates/SharedPointer.h"
#include "Serialization/Archive.h"
#include "Misc/NetworkGuid.h"
 
class AActor;
class FObjectReplicator;
class FNetworkObjectList;
 
namespace UE::Net
{
    typedef TFunctionRef<void(FObjectKey OwnerActorKey, FObjectKey ObjectKey, const TSharedRef<FObjectReplicator>& ReplicatorRef)> FExecuteForEachDormantReplicator;
 
    typedef TMap<FNetworkGUID, TWeakObjectPtr<UObject>> FDormantObjectMap;
}
 
namespace UE::Net::Private
{
 
struct FDormantObjectReplicator
{
    explicit FDormantObjectReplicator(FObjectKey InObjectKey);
 
    explicit FDormantObjectReplicator(FObjectKey InObjectKey, const TSharedRef<FObjectReplicator>& ExistingReplicator);
 
    bool operator==(const FDormantObjectReplicator& rhs) const { return ObjectKey == rhs.ObjectKey; }
    bool operator==(FObjectKey rhs) const { return ObjectKey == rhs; }
 
    FObjectKey ObjectKey;
 
    TSharedRef<FObjectReplicator> Replicator;
};
 
 
struct FActorDormantReplicators
{
    explicit FActorDormantReplicators(FObjectKey InOwnerActorKey) : OwnerActorKey(InOwnerActorKey) {}
 
    bool operator==(const FActorDormantReplicators& rhs) const { return OwnerActorKey == rhs.OwnerActorKey; }
    bool operator==(FObjectKey rhs) const { return OwnerActorKey == rhs; }
 
    void CountBytes(FArchive& Ar) const { DormantReplicators.CountBytes(Ar); }
 
    struct FDormantObjectReplicatorKeyFuncs : BaseKeyFuncs<FDormantObjectReplicator, FObjectKey, false>
    {
        static KeyInitType GetSetKey(ElementInitType Element) { return Element.ObjectKey; }
        static bool Matches(KeyInitType lhs, KeyInitType rhs) { return lhs == rhs; }
        static uint32 GetKeyHash(KeyInitType Key) { return GetTypeHash(Key); }
    };
 
    FObjectKey OwnerActorKey;
 
    typedef TSet<FDormantObjectReplicator, FDormantObjectReplicatorKeyFuncs> FObjectReplicatorSet;
    FObjectReplicatorSet DormantReplicators;
};
 
struct FDormantReplicatorHolder
{
    bool DoesReplicatorExist(AActor* DormantActor, UObject* ReplicatedObject) const;
 
    TSharedPtr<FObjectReplicator> FindReplicator(AActor* DormantActor, UObject* ReplicatedObject);
 
    TSharedPtr<FObjectReplicator> FindAndRemoveReplicator(AActor* DormantActor, UObject* ReplicatedObject);
 
    const TSharedRef<FObjectReplicator>& CreateAndStoreReplicator(AActor* DormantActor, UObject* ReplicatedObject, bool& bOverwroteExistingReplicator);
 
    void StoreReplicator(AActor* DormantActor, UObject* ReplicatedObject, const TSharedRef<FObjectReplicator>& ObjectReplicator);
 
    bool RemoveStoredReplicator(AActor* DormantActor, FObjectKey ReplicatedObjectKey);
 
    void CleanupAllReplicatorsOfActor(AActor* DormantActor);
 
    void CleanupStaleObjects(FNetworkObjectList& NetworkObjectList, UObject* ReferenceOwner);
 
    void ForEachDormantReplicator(UE::Net::FExecuteForEachDormantReplicator Function);
 
    void ForEachDormantReplicatorOfActor(AActor* DormantActor, UE::Net::FExecuteForEachDormantReplicator Function);
 
    void EmptySet();
 
    void CountBytes(FArchive& Ar) const;
 
    struct FActorDormantReplicatorsKeyFuncs : BaseKeyFuncs<FActorDormantReplicators, FObjectKey, false>
    {
        static KeyInitType GetSetKey(ElementInitType Element) { return Element.OwnerActorKey; }
        static bool Matches(KeyInitType lhs, KeyInitType rhs) { return lhs == rhs; }
        static uint32 GetKeyHash(KeyInitType Key) { return GetTypeHash(Key); }
    };
 
    typedef TSet<FActorDormantReplicators, FActorDormantReplicatorsKeyFuncs> FActorReplicatorSet;
    FActorReplicatorSet ActorReplicatorSet;
 
    UE::Net::FDormantObjectMap* FindFlushedObjectsForActor(AActor* Actor);
 
    UE::Net::FDormantObjectMap& FindOrAddFlushedObjectsForActor(AActor* Actor);
 
    void ClearFlushedObjectsForActor(AActor* Actor);
 
    TMap<FObjectKey, UE::Net::FDormantObjectMap> FlushedObjectMap;
};
 
}//end namespace UE::Net::Private