KeyHandle.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/ArrayView.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "KeyHandle.generated.h"
 
struct FKeyHandle
{
    ENGINE_API FKeyHandle();
 
    static ENGINE_API FKeyHandle Invalid();
 
    ENGINE_API bool IsValid() const;
 
    operator bool() const { return IsValid(); }
 
    bool operator ==(const FKeyHandle& Other) const
    {
        return Index == Other.Index;
    }
    
    bool operator !=(const FKeyHandle& Other) const
    {
        return Index != Other.Index;
    }
 
    friend bool operator<(FKeyHandle A, FKeyHandle B)
    {
        return A.Index < B.Index;
    }
 
    friend bool operator>(FKeyHandle A, FKeyHandle B)
    {
        return A.Index > B.Index;
    }
 
    friend uint32 GetTypeHash(const FKeyHandle& Handle)
    {
        return GetTypeHash(Handle.Index);
    }
 
    friend FArchive& operator<<(FArchive& Ar,FKeyHandle& Handle)
    {
        Ar << Handle.Index;
        return Ar;
    }
 
private:
 
    explicit FKeyHandle(uint32 SpecificIndex);
 
    uint32 Index;
};
 
 
USTRUCT()
struct FKeyHandleMap
{
    GENERATED_USTRUCT_BODY()
public:
    FKeyHandleMap() {}
 
    // This struct is not copyable.  This must be public or because derived classes are allowed to be copied
    FKeyHandleMap( const FKeyHandleMap& Other ) {}
    void operator=(const FKeyHandleMap& Other) {}
 
    // Quickly initializes this map by clearing it and filling with KeyHandles in O(n) time, instead of O(n^2) if Add() was used in a loop.
    void Initialize(TArrayView<const FKeyHandle> InKeyHandles);
 
    void Add( const FKeyHandle& InHandle, int32 InIndex );
    void Empty(int32 ExpectedNumElements = 0);
    void Remove( const FKeyHandle& InHandle );
    void Reserve(int32 NumElements);
    const int32* Find(const FKeyHandle& InHandle) const { return KeyHandlesToIndices.Find(InHandle); }
    const FKeyHandle* FindKey( int32 KeyIndex ) const;
    int32 Num() const { return KeyHandlesToIndices.Num(); }
    TArray<FKeyHandle>::TConstIterator CreateConstIterator() const { return KeyHandles.CreateConstIterator(); }
    const TMap<FKeyHandle, int32>& GetMap() const { return KeyHandlesToIndices; }
 
    void SetKeyHandles(int32 Num);
 
    bool Serialize(FArchive& Ar);
    bool operator==(const FKeyHandleMap& Other) const { return KeyHandles == Other.KeyHandles; }
    bool operator!=(const FKeyHandleMap& Other) const { return !(*this==Other); }
 
    friend FArchive& operator<<(FArchive& Ar,FKeyHandleMap& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
 
    // Ensures that all indices have a valid handle and that there are no handles left to invalid indices
    void EnsureAllIndicesHaveHandles(int32 NumIndices);
    
    // Ensures a handle exists for the specified Index
    void EnsureIndexHasAHandle(int32 KeyIndex);
 
private:
 
    TMap<FKeyHandle, int32> KeyHandlesToIndices;
    TArray<FKeyHandle> KeyHandles;
};
 
 
template<>
struct TStructOpsTypeTraits<FKeyHandleMap>
    : public TStructOpsTypeTraitsBase2<FKeyHandleMap>
{
    enum 
    {
        WithSerializer = true,
        WithCopy = false,
        WithIdenticalViaEquality = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
USTRUCT()
struct FKeyHandleLookupTable
{
    GENERATED_BODY()
public:
    ENGINE_API int32 GetIndex(FKeyHandle KeyHandle);
 
    ENGINE_API FKeyHandle FindOrAddKeyHandle(int32 Index);
 
    ENGINE_API void MoveHandle(int32 OldIndex, int32 NewIndex);
 
    ENGINE_API FKeyHandle AllocateHandle(int32 Index);
 
    ENGINE_API void DeallocateHandle(int32 Index);
 
    ENGINE_API void ReplaceHandle(int32 Index, FKeyHandle HandleToReplace);
 
    ENGINE_API void Reset();
 
    ENGINE_API bool Serialize(FArchive& Ar);
    friend FArchive& operator<<(FArchive& Ar, FKeyHandleLookupTable& P)
    {
        P.Serialize(Ar);
        return Ar;
    }
 
private:
 
    void RelocateKeyHandles(int32 StartAtIndex, int32 DeltaIndex);
 
private:
    TSparseArray<FKeyHandle> KeyHandles;
 
    TMap<FKeyHandle, int32> KeyHandlesToIndices;
 
};
 
template<>
struct TStructOpsTypeTraits<FKeyHandleLookupTable>
    : public TStructOpsTypeTraitsBase2<FKeyHandleLookupTable>
{
    enum
    {
        WithSerializer = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};