Fingerprint.h

/*
 * ░▒▓ APPARATUS ▓▒░
 * 
 * File: Fingerprint.h
 * Created: Friday, 23rd October 2020 7:00:48 pm
 * Author: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * Last Modified: Tuesday, 6th April 2021 1:42:33 pm
 * Modified By: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * 
 * The Apparatus source code is for your internal usage only.
 * Redistribution of this file is strictly prohibited.
 * 
 * Community forums: https://talk.turbanov.ru
 * 
 * Copyright 2020 - 2021, SP Vladislav Dmitrievich Turbanov
 * Made in Russia, Moscow City, Chekhov City
 */
 
#pragma once
 
#include <map>
#include <ostream>
#include <typeinfo>
 
#include "CoreUObject.h"
#include "Engine.h"
#include "UObject/Class.h"
 
#include "BitMask.h"
#include "Detail.h"
 
#include "Fingerprint.generated.h"
 
FORCEINLINE uint32 GetTypeHash(const UClass* Type)
{
    return Type->GetUniqueID();
}
 
UENUM(BlueprintType, Meta = (Bitflags))
enum class EBootFilter : uint8
{
    None = 0x0 UMETA(Hidden),
    Booted = 1 << 0 UMETA(DisplayName = "Booted"),
    Halted = 1 << 1 UMETA(DisplayName = "Halted"),
    All = Booted | Halted UMETA(DisplayName = "Booted + Halted")
};
 
ENUM_CLASS_FLAGS(EBootFilter)
 
 
FORCEINLINE uint32 GetTypeHash(const EBootFilter BootFilter)
{
    return (uint32)BootFilter;
}
 
FORCEINLINE UEnum* GetBootFilterClass()
{
    auto EnumPtr = FindObject<UEnum>(ANY_PACKAGE, TEXT("EBootFilter"), true);
    verify(EnumPtr);
    return EnumPtr;
}
 
FORCEINLINE EBootFilter BootFilterFromState(const bool bState)
{
    return bState ? EBootFilter::Booted : EBootFilter::Halted;
}
 
FORCEINLINE FString BootFilterToString(const EBootFilter BootFilter)
{
    const UEnum* EnumPtr = GetBootFilterClass();
    if (!EnumPtr)
    {
        return FString("Invalid");
    }
 
    return EnumPtr->GetNameByValue((int64)BootFilter).ToString();
}
 
USTRUCT(BlueprintType, Meta = (HasNativeMake = "ApparatusRuntime.ApparatusFunctionLibrary.MakeFingerprint"))
struct APPARATUSRUNTIME_API FFingerprint
{
    GENERATED_BODY()
 
  private:
    static int32 NextDetailId;
 
    static TMap<const UClass*, int32> DetailIds;
 
    static TMap<const UClass*, FBitMask> DetailsMasksByTypes;
 
    static TMap<const UClass*, FBitMask> ExcludedDetailsMasksByTypes;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Apparatus,
              Meta = (AllowPrivateAccess = "true"))
    TArray<TSubclassOf<class UDetail>> Details;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Apparatus,
              Meta = (AllowPrivateAccess = "true"))
    mutable FBitMask DetailsMask;
 
    friend uint32 GetTypeHash(const FFingerprint& Fingerprint);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Apparatus,
              Meta = (AllowPrivateAccess = "true"))
    EBootFilter BootState = EBootFilter::None;
 
    friend struct FFilter;
    friend class UBelt;
    friend class AMechanism;
    friend class UApparatusFunctionLibrary;
 
  public:
    static int32 GetDetailId(const TSubclassOf<class UDetail> DetailType);
 
    static const FBitMask&
    GetDetailMask(const TSubclassOf<class UDetail> DetailType);
 
    static const FBitMask&
    GetExcludedDetailMask(const TSubclassOf<class UDetail> DetailType);
 
    FORCEINLINE static const FBitMask&
    GetDetailMask(const class UDetail* Detail)
    {
        return GetDetailMask(Detail->GetClass());
    }
 
    FORCEINLINE static const FBitMask&
    GetExcludedDetailMask(const class UDetail* Detail)
    {
        return GetExcludedDetailMask(Detail->GetClass());
    }
    template <class T> FORCEINLINE static const FBitMask& GetDetailMask()
    {
        return GetDetailMask(T::StaticType());
    }
 
    FORCEINLINE EBootFilter GetBootState() const { return BootState; }
 
    FORCEINLINE bool SetBootState(EBootFilter InBootState)
    {
        if (BootState == InBootState) return false;
        BootState = InBootState;
        return true;
    }
 
    FORCEINLINE bool SetBooted(bool bState = true)
    {
        return SetBootState(bState ? EBootFilter::Booted : EBootFilter::Halted);
    }
 
    FORCEINLINE bool IsBooted() const
    {
        return BootState == EBootFilter::Booted;
    }
 
    FORCEINLINE const TArray<TSubclassOf<class UDetail>>& GetDetails() const
    {
        return Details;
    }
 
    FORCEINLINE int32 GetDetailsCount() const { return Details.Num(); }
 
    FORCEINLINE const FBitMask& GetDetailsMask() const { return DetailsMask; }
 
    FORCEINLINE TSubclassOf<class UDetail> DetailAt(const int32 Index) const
    {
        return Details[Index];
    }
 
    FORCEINLINE explicit operator TArray<TSubclassOf<class UDetail>>() const
    {
        TArray<TSubclassOf<class UDetail>> Types;
        for (auto Detail : Details)
        {
            Types.Add(Detail);
        }
        return Types;
    }
 
    FORCEINLINE explicit operator TSet<UClass*>() const
    {
        TSet<UClass*> Types;
        for (auto Detail : Details)
        {
            Types.Add(Detail);
        }
        return Types;
    }
 
    FORCEINLINE operator bool() const
    {
        return Details.Num() > 0 || BootState != EBootFilter::None;
    }
 
    FORCEINLINE void
    GetMappingFrom(const TArray<TSubclassOf<class UDetail>>& Fingerprint,
                   TArray<int32>& OutMapping) const
    {
        OutMapping.Reset(Fingerprint.Num());
        for (int32 i = 0; i < Fingerprint.Num(); ++i)
        {
            OutMapping.Add(IndexOf(Fingerprint[i]));
        }
    }
 
    FORCEINLINE void
    GetMappingFrom(const TArray<TSubclassOf<class UDetail>>& Fingerprint,
                   TArray<TArray<int32>>& OutMapping) const
    {
        OutMapping.Reset(Fingerprint.Num());
        for (int32 i = 0; i < Fingerprint.Num(); ++i)
        {
            GetIndicesOf(Fingerprint[i], OutMapping.AddDefaulted_GetRef());
        }
    }
 
    FORCEINLINE void GetMappingFrom(const FFingerprint& Fingerprint,
                                    TArray<int32>& OutMapping) const
    {
        OutMapping.Reset(Fingerprint.GetDetailsCount());
        for (auto Detail : Fingerprint.Details)
        {
            OutMapping.Add(IndexOf(Detail));
        }
    }
 
    FORCEINLINE void GetMappingTo(const FFingerprint& Fingerprint,
                                    TArray<int32>& OutMapping) const
    {
        Fingerprint.GetMappingFrom(*this, OutMapping);
    }
 
    FORCEINLINE void GetMappingFrom(const FFingerprint& Fingerprint,
                                    TArray<TArray<int32>>& OutMapping) const
    {
        OutMapping.Reset(Fingerprint.GetDetailsCount());
        for (auto Detail : Fingerprint.Details)
        {
            GetIndicesOf(Detail, OutMapping.AddDefaulted_GetRef());
        }
    }
 
    FORCEINLINE void GetMappingTo(const FFingerprint& Fingerprint,
                                  TArray<TArray<int32>>& OutMapping) const
    {
        Fingerprint.GetMappingFrom(*this, OutMapping);
    }
 
    FORCEINLINE bool Contains(const FFingerprint& Fingerprint) const
    {
        return GetDetailsMask().Includes(Fingerprint.GetDetailsMask());
    }
 
    FORCEINLINE bool Contains(const TSubclassOf<class UDetail> DetailType) const
    {
        const FBitMask& Mask = GetDetailMask(DetailType);
        return GetDetailsMask().Includes(Mask);
    }
 
    bool Matches(const struct FFilter& Filter) const;
 
    bool Matches(const struct FFingerprint& Fingerprint) const;
 
    int32 IndexOf(const TSubclassOf<class UDetail> DetailType) const;
 
    bool GetIndicesOf(const TSubclassOf<class UDetail> DetailType,
                      TArray<int32>& OutIndices) const;
 
    FORCEINLINE FFingerprint() {}
 
    FFingerprint(const class ISubjective* Subjective);
 
    FFingerprint(const class UDetail* Detail);
 
    FFingerprint(const TSubclassOf<class UDetail> DetailType);
 
    FFingerprint(const TSet<TSubclassOf<class UDetail>>& DetailTypes);
 
    template <typename OtherAllocator>
    FFingerprint(const TArray<UDetail*, OtherAllocator>& Details,
                 const EBootFilter InBootState = EBootFilter::None);
 
    FFingerprint(const TArray<TSubclassOf<class UDetail>>& InDetailTypes,
                 const EBootFilter InBootState = EBootFilter::None);
 
    FFingerprint(const FFingerprint& Fingerprint);
 
    bool Set(const FFingerprint& Fingerprint);
 
    bool Set(const TArray<TSubclassOf<class UDetail>>& DetailTypes);
 
    bool Set(const TSet<TSubclassOf<class UDetail>>& DetailTypes);
 
    bool Set(const TArray<UDetail*>& InDetails, const EBootFilter InBootState = EBootFilter::None);
 
    bool Set(const TSet<UDetail*>& Details);
 
    bool Set(const ISubjective* Subjective);
 
    FORCEINLINE FFingerprint& operator=(const FFingerprint& Fingerprint)
    {
        Set(Fingerprint);
        return *this;
    }
 
    FORCEINLINE FFingerprint&
    operator=(const TArray<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Set(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFingerprint&
    operator=(const TSet<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Set(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator=(const TArray<class UDetail*>& InDetails)
    {
        Set(InDetails);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator=(const TSet<class UDetail*>& InDetails)
    {
        Set(InDetails);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator=(const ISubjective* Subjective)
    {
        Set(Subjective);
        return *this;
    }
 
    bool Add(std::initializer_list<TSubclassOf<class UDetail>> DetailTypes);
 
    bool Add(const FFingerprint& Fingerprint);
 
    bool Add(const FFingerprint& Fingerprint, EBootFilter InBootState);
 
    bool Add(const TArray<TSubclassOf<class UDetail>>& DetailTypes);
 
    bool Add(const TSet<TSubclassOf<class UDetail>>& DetailTypes);
 
    bool Add(const TArray<class UDetail*>& InDetails,
             const EBootFilter InBootState = EBootFilter::None);
 
    bool Add(const TSet<class UDetail*>& InDetails);
 
    bool Add(TSubclassOf<class UDetail> DetailType);
 
    bool Add(const ISubjective* Subjective);
 
    template <class T> FORCEINLINE bool Add() { return Add(T::StaticClass()); }
 
    bool ContainsDetail(const TSubclassOf<class UDetail> DetailType) const;
 
    bool ContainsDetail(const class UDetail* Detail) const;
 
    FORCEINLINE FFingerprint&
    operator+=(std::initializer_list<TSubclassOf<class UDetail>> DetailTypes)
    {
        Add(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator+=(const FFingerprint& Fingerprint)
    {
        Add(Fingerprint);
        return *this;
    }
 
    FORCEINLINE FFingerprint&
    operator+=(const TArray<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Add(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFingerprint&
    operator+=(const TSet<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Add(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator+=(const TArray<UDetail*>& InDetails)
    {
        Add(InDetails);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator+=(const TSet<UDetail*>& InDetails)
    {
        Add(InDetails);
        return *this;
    }
 
    FORCEINLINE FFingerprint& operator+=(TSubclassOf<class UDetail> DetailType)
    {
        Add(DetailType);
        return *this;
    }
 
    bool Remove(const TSubclassOf<class UDetail> DetailType);
 
    FORCEINLINE FFingerprint& operator-=(TSubclassOf<class UDetail> DetailType)
    {
        Remove(DetailType);
        return *this;
    }
 
    template <class T> FORCEINLINE bool Remove()
    {
        return Remove(T::StaticClass());
    }
 
    bool Remove(const UDetail* Detail);
 
    FORCEINLINE void Reset()
    {
        Details.Reset();
        DetailsMask.Reset();
        BootState = EBootFilter::None;
    }
 
    FString ToString() const;
 
    const static struct FFingerprint ZERO;
}; // USTRUCT Fingerprint
 
FORCEINLINE bool FFingerprint::Matches(const FFingerprint& Fingerprint) const
{
    return GetDetailsMask().Includes(Fingerprint.GetDetailsMask()) &&
           ((GetBootState() & Fingerprint.GetBootState()) != EBootFilter::None);
}
 
FORCEINLINE bool operator==(const FFingerprint& A, const FFingerprint& B)
{
    if (std::addressof(A) == std::addressof(B))
        return true;
 
    if (A.GetDetailsMask() != B.GetDetailsMask())
        return false;
    if (A.GetBootState() != B.GetBootState())
        return false;
 
    return true;
}
 
FORCEINLINE bool operator!=(const FFingerprint& A, const FFingerprint& B)
{
    if (std::addressof(A) == std::addressof(B))
        return false;
 
    if (A.GetDetailsMask() != B.GetDetailsMask())
        return true;
    if (A.GetBootState() != B.GetBootState())
        return true;
 
    return false;
}
 
FORCEINLINE uint32 GetTypeHash(const FFingerprint& Fingerprint)
{
    uint32 hash = 1519974369;
 
    hash = hash * 1521134295 + GetTypeHash(Fingerprint.GetDetailsMask());
    hash = hash * 1521134295 + GetTypeHash(Fingerprint.GetBootState());
 
    return hash;
}
 
FORCEINLINE bool FFingerprint::Set(const FFingerprint& Fingerprint)
{
    Reset();
 
    return Add(Fingerprint);
}
 
FORCEINLINE bool FFingerprint::Set(const TArray<TSubclassOf<UDetail>>& Types)
{
    Reset();
 
    return Add(Types);
}
 
FORCEINLINE bool FFingerprint::Set(const TSet<TSubclassOf<UDetail>>& Types)
{
    Reset();
 
    return Add(Types);
}
 
FORCEINLINE bool FFingerprint::Set(const TArray<UDetail*>& InDetails,
                                   const EBootFilter InBootState)
{
    Reset();
 
    return Add(InDetails, InBootState);
}
 
FORCEINLINE bool FFingerprint::Set(const TSet<UDetail*>& InDetails)
{
    Reset();
 
    return Add(InDetails);
}
 
FORCEINLINE bool FFingerprint::Set(const ISubjective* Subjective)
{
    check(Subjective);
 
    Reset();
 
    return Add(Subjective);
}
 
template <typename OtherAllocator>
inline FFingerprint::FFingerprint(const TArray<UDetail*, OtherAllocator>& InDetails,
                                  const EBootFilter InBootFilter)
    : DetailsMask(NextDetailId),
      BootState(InBootFilter)
{
    for (auto Detail : InDetails)
    {
        if (!Detail)
            continue;
        if (!Detail->IsEnabled())
            continue;
 
        const FBitMask& Mask = GetDetailMask(Detail);
        if (DetailsMask.Includes(Mask))
            continue;
        DetailsMask.OrWith(Mask);
        Details.Add(Detail->GetClass());
    }
}
 
FORCEINLINE bool FFingerprint::ContainsDetail(const TSubclassOf<UDetail> DetailType) const
{
    checkf(DetailType,
           TEXT("The detail type must be provided for detail checks."));
    const FBitMask& Mask = GetDetailMask(DetailType);
    return DetailsMask.Includes(Mask);
}
 
FORCEINLINE bool FFingerprint::ContainsDetail(const class UDetail* Detail) const
{
    checkf(Detail,
           TEXT("The detail must be provided for detail checks."));
    if (!Detail->IsEnabled())
        return false;
    const FBitMask& Mask = GetDetailMask(Detail->GetClass());
    return DetailsMask.Includes(Mask);
}