BeltSlot.h

/*
 * ░▒▓ APPARATUS ▓▒░
 * 
 * File: BeltSlot.h
 * Created: Friday, 23rd October 2020 7:00:48 pm
 * Author: Vladislav Dmitrievich Turbanov (vladislav@turbanov.ru)
 * ───────────────────────────────────────────────────────────────────
 * Last Modified: Friday, 26th March 2021 9:50:00 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 "CoreMinimal.h"
#include "UObject/NoExportTypes.h"
#include "UObject/WeakInterfacePtr.h"
 
#include "BeltSlotCache.h"
#include "Fingerprint.h"
#include "Filter.h"
 
#include "BeltSlot.generated.h"
 
USTRUCT(BlueprintType)
struct APPARATUSRUNTIME_API FBeltSlot
{
    GENERATED_BODY()
 
public:
 
    static const int32 InvalidIndex = -1;
 
private:
 
    friend class USubjectiveActorComponent;
    friend class UBelt;
 
    mutable TWeakInterfacePtr<class ISubjective> Subjective = nullptr;
 
    UPROPERTY(Meta = (AllowPrivateAccess = "true"))
        mutable TArray<FBeltSlotCache> Details;
 
    mutable int32 DetailsCount = 0;
 
    mutable int32 Iteration = 0;
 
    mutable int32 IterationsCount = 0;
 
    TWeakObjectPtr<class UBelt> Owner;
 
    mutable int32 Index = InvalidIndex;
 
public:
 
    FORCEINLINE class UBelt* GetOwner() const { return Owner.Get(); }
 
    bool IsBuffering() const;
 
    FORCEINLINE int32 GetIndex() const { return Index; }
 
    FORCEINLINE int32 GetIteration() const { return Iteration; }
 
    TScriptInterface<class ISubjective> GetSubjective() const;
 
    void SetSubjective(TScriptInterface<class ISubjective> InSubject);
 
    void ClearDetails() const;
 
    FORCEINLINE FBeltSlot() {}
 
    FORCEINLINE FBeltSlot(class UBelt* o, int32 i) : Owner(o), Index(i) {}
 
    ~FBeltSlot();
 
    FBeltSlot(UBelt* o);
 
    bool FetchDetails(const FBeltSlot& Slot, const TArray<int>& Passport);
 
    bool FetchDetails(const FBeltSlot& Slot, const TArray<TArray<int>>& Mapping);
 
    FORCEINLINE bool IsPresent(const int32 DetailIndex)
    {
        if (DetailIndex < 0)
            return false;
        if (DetailIndex >= DetailsCount)
            return false;
 
        return Details[DetailIndex].GetDetailsCount() > 0;
    }
 
    UDetail* GetDetail(const int32 DetailIndex) const;
 
    UDetail* GetDetail(const TSubclassOf<UDetail> DetailType) const;
 
    FORCEINLINE UDetail* operator[](const int32 DetailIndex)
    {
        return GetDetail(DetailIndex);
    }
 
    bool FetchDetails();
 
    bool FetchDetails(const TArray<class UDetail*>& Details);
 
    bool FetchForNext();
 
    bool IsValid() const;
 
    const FFilter& GetFilter() const;
 
    FORCEINLINE operator bool() const { return IsValid(); }
 
    FBeltSlot& GetNext();
 
    FORCEINLINE bool operator!=(const FBeltSlot& slot) const
    {
        return Owner != slot.Owner || Index != slot.Index;
    }
 
    FORCEINLINE bool operator==(const FBeltSlot& slot) const
    {
        return Owner == slot.Owner && Index == slot.Index;
    }
 
    FORCEINLINE FBeltSlot& operator=(const FBeltSlot& Slot)
    {
        checkf(Owner == Slot.Owner,
            TEXT("Move-copying slots from different belts is not supported."));
        checkf(DetailsCount == Slot.DetailsCount,
            TEXT("Move-copying slots of different details counts is not supported."));
        check(Index != -1);
        check(Slot.Index != -1);
 
        if (Index == Slot.Index) return *this;
 
        for (int32 i = 0; i < Slot.DetailsCount; i++)
        {
            Details[i] = Slot.Details[i];
        }
 
        Subjective = Slot.Subjective;
        IterationsCount = Slot.IterationsCount;
        Iteration = 0;
 
        return *this;
    }
 
    void Reserve();
}; // struct FBeltSlot
 
FORCEINLINE FBeltSlot::~FBeltSlot() {}
 
FORCEINLINE UDetail* FBeltSlot::GetDetail(const TSubclassOf<UDetail> DetailType) const
{
    check(DetailType);
    const FFilter& Filter = GetFilter();
    const int32 TypeIndex = Filter.IndexOf(DetailType);
    checkf(TypeIndex >= 0, TEXT("Invalid index for type: %s"),
           *DetailType->GetName());
    return GetDetail(TypeIndex);
}
 
FORCEINLINE TScriptInterface<class ISubjective> FBeltSlot::GetSubjective() const
{
    if (Subjective.IsValid())
    {
        return Subjective.ToScriptInterface();
    }
    ClearDetails();
    return nullptr;
}
 
FORCEINLINE void FBeltSlot::ClearDetails() const
{
    for (int32 i = 0; i < DetailsCount; i++)
    {
        Details[i].Reset();
    }
    DetailsCount = 0;
    IterationsCount = 0;
}
 
FORCEINLINE void FBeltSlot::SetSubjective(TScriptInterface<ISubjective> InSubjective)
{
    if (Subjective == TWeakInterfacePtr<ISubjective>(*InSubjective))
    {
        // Nothing needs to be changed:
        return;
    }
 
    Subjective = InSubjective;
    ClearDetails();
}