Filter.h

/*
 * ░▒▓ APPARATUS ▓▒░
 * 
 * File: Filter.h
 * Created: Friday, 23rd October 2020 7:00:48 pm
 * Author: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * Last Modified: Friday, 26th March 2021 5:16:52 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 2021 - 2021, SP Vladislav Dmitrievich Turbanov
 * Made in Russia, Moscow City, Chekhov City
 */
 
#pragma once
 
#include <map>
#include <ostream>
#include <typeinfo>
 
#include "BitMask.h"
#include "CoreUObject.h"
#include "Engine.h"
#include "UObject/Class.h"
 
#include "Detail.h"
#include "Fingerprint.h"
 
#include "Filter.generated.h"
 
USTRUCT(BlueprintType,
        Meta = (HasNativeMake = "ApparatusRuntime.ApparatusFunctionLibrary.MakeFilter",
                HasNativeBreak = "ApparatusRuntime.ApparatusFunctionLibrary.BreakFilter"))
struct APPARATUSRUNTIME_API FFilter
{
    GENERATED_BODY()
 
  private:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Apparatus,
              Meta = (AllowPrivateAccess = "true"))
    FFingerprint Fingerprint;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Apparatus,
              Meta = (AllowPrivateAccess = "true"))
    TArray<TSubclassOf<class UDetail>> ExcludedDetails;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Apparatus,
              Meta = (AllowPrivateAccess = "true"))
    mutable FBitMask ExcludedDetailsMask;
 
    friend uint32 GetTypeHash(const FFilter& Filter);
 
    friend class UBelt;
    friend class UMechanism;
    friend class UApparatusFunctionLibrary;
 
  public:
 
    FORCEINLINE EBootFilter GetBootFilter() const { return Fingerprint.GetBootState(); }
 
    FORCEINLINE void SetBootFilter(EBootFilter NewBootFilter)
    {
        Fingerprint.SetBootState(NewBootFilter);
    }
 
    FORCEINLINE const FFingerprint& GetFingerprint() const
    {
        return Fingerprint;
    }
 
    FORCEINLINE const TArray<TSubclassOf<class UDetail>>& GetDetails() const
    {
        return Fingerprint.Details;
    }
 
    FORCEINLINE const TArray<TSubclassOf<class UDetail>>& GetExcludedDetails() const
    {
        return ExcludedDetails;
    }
 
    FORCEINLINE int32 GetDetailsCount() const { return Fingerprint.Details.Num(); }
 
    FORCEINLINE int32 GetExcludedDetailsCount() const { return ExcludedDetails.Num(); }
 
    FORCEINLINE const FBitMask& GetDetailsMask() const { return Fingerprint.DetailsMask; }
 
    FORCEINLINE const FBitMask& GetExcludedDetailsMask() const
    {
        return ExcludedDetailsMask;
    }
 
    FORCEINLINE TSubclassOf<class UDetail> DetailAt(const int32 Index) const
    {
        return Fingerprint.Details[Index];
    }
 
    FORCEINLINE TSubclassOf<class UDetail> ExcludedDetailAt(const int32 Index) const
    {
        return ExcludedDetails[Index];
    }
 
    FORCEINLINE bool IsEffective() const
    {
        return (Fingerprint.Details.Num() > 0) ||
               (ExcludedDetails.Num() > 0) ||
               (Fingerprint.BootState != EBootFilter::None);
    }
 
    FORCEINLINE operator bool() const
    {
        return IsEffective();
    }
 
    FORCEINLINE int32 IndexOf(const TSubclassOf<class UDetail> DetailType) const
    {
        return Fingerprint.IndexOf(DetailType);
    }
 
    FORCEINLINE bool GetIndicesOf(const TSubclassOf<class UDetail> DetailType,
                                  TArray<int32>& OutIndices) const
    {
        return Fingerprint.GetIndicesOf(DetailType, OutIndices);
    }
 
    FORCEINLINE FFilter() {}
 
    FORCEINLINE FFilter(const FFingerprint& InFingerprint)
        : Fingerprint(InFingerprint)
    {
    }
 
    FORCEINLINE FFilter(const class ISubjective* Subjective)
        : Fingerprint(Subjective)
    {
    }
 
    FORCEINLINE FFilter(const class UDetail* Detail): Fingerprint(Detail)
    {}
 
    FORCEINLINE FFilter(const TSubclassOf<class UDetail> DetailType): Fingerprint(DetailType)
    {}
 
    FORCEINLINE FFilter(const TArray<TSubclassOf<class UDetail>>& DetailTypes): Fingerprint(DetailTypes)
    {}
 
    FORCEINLINE FFilter(const TSet<TSubclassOf<class UDetail>>& DetailTypes): Fingerprint(DetailTypes)
    {}
 
    FORCEINLINE FFilter(const TArray<UDetail*>& Details): Fingerprint(Details)
    {}
 
    FFilter(const TArray<TSubclassOf<class UDetail>>& Types,
            const TArray<TSubclassOf<class UDetail>>& ExcludedTypes);
 
    FFilter(const TArray<TSubclassOf<class UDetail>>& Types,
            const TArray<TSubclassOf<class UDetail>>& ExcludedTypes,
            const EBootFilter InBootFilter);
 
    FORCEINLINE FFilter(const FFilter& Filter)
        : Fingerprint(Filter.Fingerprint),
          ExcludedDetails(Filter.ExcludedDetails),
          ExcludedDetailsMask(Filter.ExcludedDetailsMask)
    {}
 
    void Set(const FFilter& Filter);
 
    void Set(const TArray<TSubclassOf<class UDetail>>& DetailTypes);
 
    void Set(const TSet<TSubclassOf<class UDetail>>& DetailTypes);
 
    void Set(const TArray<UDetail*>& Details);
 
    void Set(const TSet<UDetail*>& Details);
 
    void Set(const ISubjective* Subjective);
 
    FORCEINLINE FFilter& operator=(const FFilter& Filter)
    {
        Set(Filter);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator=(const TArray<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Set(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator=(const TSet<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Set(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFilter& operator=(const TArray<class UDetail*>& Details)
    {
        Set(Details);
        return *this;
    }
 
    FORCEINLINE FFilter& operator=(const TSet<class UDetail*>& Details)
    {
        Set(Details);
        return *this;
    }
 
    FORCEINLINE FFilter& operator=(const ISubjective* Subjective)
    {
        Set(Subjective);
        return *this;
    }
 
    FORCEINLINE void Include(std::initializer_list<TSubclassOf<class UDetail>> DetailTypes)
    {
        Fingerprint.Add(DetailTypes);
    }
 
    FORCEINLINE void Include(const TArray<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Fingerprint.Add(DetailTypes);
    }
 
    FORCEINLINE void Include(const TSet<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Fingerprint.Add(DetailTypes);
    }
 
    FORCEINLINE void Include(const TArray<class UDetail*>& Details)
    {
        Fingerprint.Add(Details);
    }
 
    FORCEINLINE void Include(const TSet<class UDetail*>& Details)
    {
        Fingerprint.Add(Details);
    }
 
    FORCEINLINE void Include(const FFingerprint& InFingerprint)
    {
        Fingerprint.Add(InFingerprint);
    }
 
    FORCEINLINE void Include(TSubclassOf<class UDetail> DetailType)
    {
        Fingerprint.Add(DetailType);
    }
 
    FORCEINLINE void Include(const ISubjective* Subjective)
    {
        Fingerprint.Add(Subjective);
    }
 
    FORCEINLINE bool
    Includes(const TSubclassOf<class UDetail> DetailType) const
    {
        return Fingerprint.Contains(DetailType);
    }
 
    FORCEINLINE bool
    Includes(const class UDetail* Detail) const
    {
        return Fingerprint.Contains(Detail);
    }
 
    FORCEINLINE bool
    Excludes(const TSubclassOf<class UDetail> Type) {
        const FBitMask& Mask = FFingerprint::GetExcludedDetailMask(Type);
        return ExcludedDetailsMask.Includes(Mask);
    }
 
    template <class T> FORCEINLINE bool Include() { return Include(T::StaticClass()); }
 
    FORCEINLINE FFilter&
    operator+=(std::initializer_list<TSubclassOf<class UDetail>> DetailTypes)
    {
        Include(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator+=(const struct FFingerprint& InFingerprint)
    {
        Include(InFingerprint);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator+=(const TArray<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Include(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator+=(const TSet<TSubclassOf<class UDetail>>& DetailTypes)
    {
        Include(DetailTypes);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator+=(const TArray<UDetail*>& InDetails)
    {
        Include(InDetails);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator+=(const TSet<UDetail*>& InDetails)
    {
        Include(InDetails);
        return *this;
    }
 
    FORCEINLINE FFilter&
    operator+=(TSubclassOf<class UDetail> DetailType)
    {
        Include(DetailType);
        return *this;
    }
 
    FORCEINLINE bool
    RemoveInclusion(const TSubclassOf<class UDetail> DetailType)
    {
        return Fingerprint.Remove(DetailType);
    }
 
    template <class T> FORCEINLINE bool RemoveInclusion()
    {
        return RemoveInclusion(T::StaticClass());
    }
 
    FORCEINLINE bool RemoveInclusion(const UDetail* Detail)
    {
        return Fingerprint.Remove(Detail);
    }
 
    FORCEINLINE FFilter& operator-=(TSubclassOf<class UDetail> DetailType)
    {
        RemoveInclusion(DetailType);
        return *this;
    }
 
    FORCEINLINE void Reset()
    {
        Fingerprint.Reset();
        ExcludedDetails.Reset();
        ExcludedDetailsMask.Reset();
    }
 
    bool Matches(const FFilter& Filter) const;
 
    friend bool operator==(const FFilter& A, const FFilter& B);
 
    friend bool operator!=(const FFilter& A, const FFilter& B);
 
    FString ToString() const;
 
    static struct FFilter ZERO;
}; // USTRUCT Filter
 
FORCEINLINE bool operator==(const FFilter& A, const FFilter& B)
{
    if (std::addressof(A) == std::addressof(B))
        return true;
 
    if (A.Fingerprint != B.Fingerprint)
        return false;
    if (A.GetExcludedDetailsMask() != B.GetExcludedDetailsMask())
        return false;
 
    return true;
}
 
FORCEINLINE bool operator!=(const FFilter& A, const FFilter& B)
{
    if (std::addressof(A) == std::addressof(B))
        return false;
 
    if (A.Fingerprint != B.Fingerprint)
        return true;
    if (A.GetExcludedDetailsMask() != B.GetExcludedDetailsMask())
        return true;
 
    return false;
}
 
FORCEINLINE uint32 GetTypeHash(const FFilter& Filter)
{
    uint32 hash = 1519974369;
 
    hash = hash * 1521134295 + GetTypeHash(Filter.Fingerprint);
    hash = hash * 1521134295 + GetTypeHash(Filter.GetExcludedDetailsMask());
 
    return hash;
}
 
FORCEINLINE bool FFingerprint::Matches(const FFilter& Filter) const
{
    return Matches(Filter.GetFingerprint()) &&
           !GetDetailsMask().IncludesPartially(Filter.GetExcludedDetailsMask());
}
 
FORCEINLINE bool FFilter::Matches(const FFilter& Filter) const
{
    return Fingerprint.Matches(Filter) &&
           !ExcludedDetailsMask.IncludesPartially(Filter.GetDetailsMask());
}
 
inline void FFilter::Set(const FFilter& Filter)
{
    Reset();
 
    Fingerprint = Filter.Fingerprint;
    ExcludedDetails = Filter.ExcludedDetails;
    ExcludedDetailsMask = Filter.ExcludedDetailsMask;
}
 
FORCEINLINE void FFilter::Set(const TArray<TSubclassOf<UDetail>>& Types)
{
    Reset();
 
    Include(Types);
}
 
FORCEINLINE void FFilter::Set(const TSet<TSubclassOf<UDetail>>& Types)
{
    Reset();
 
    Include(Types);
}
 
FORCEINLINE void FFilter::Set(const TArray<UDetail*>& Details)
{
    Reset();
 
    Include(Details);
}
 
FORCEINLINE void FFilter::Set(const TSet<UDetail*>& Details)
{
    Reset();
 
    Include(Details);
}
 
FORCEINLINE void FFilter::Set(const class ISubjective* Subjective)
{
    check(Subjective);
 
    Reset();
 
    Include(Subjective);
}