SubsystemCollection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Templates/Casts.h"
#include "Templates/SubclassOf.h"
#include "UObject/GCObject.h"
 
class USubsystem;
class UDynamicSubsystem;
 
DECLARE_LOG_CATEGORY_EXTERN(LogSubsystemCollection, Log, All);
 
class FSubsystemCollectionBase
{
public:
    ENGINE_API void Initialize(UObject* NewOuter);
 
    /* Clears the collection, while deinitializing the systems */
    ENGINE_API void Deinitialize();
 
    bool IsInitialized() const { return Outer != nullptr; }
 
    const UClass* GetBaseType() const { return BaseType; }
 
    ENGINE_API USubsystem* InitializeDependency(TSubclassOf<USubsystem> SubsystemClass);
 
    template <typename TSubsystemClass>
    TSubsystemClass* InitializeDependency()
    {
        return Cast<TSubsystemClass>(InitializeDependency(TSubsystemClass::StaticClass()));
    }
 
    static ENGINE_API void ActivateExternalSubsystem(UClass* SubsystemClass);
 
    static ENGINE_API void DeactivateExternalSubsystem(UClass* SubsystemClass);
 
    ENGINE_API void AddReferencedObjects(UObject* Referencer, FReferenceCollector& Collector);
protected:
    struct FSubsystemArray
    {
        TArray<USubsystem*> Subsystems;
        mutable bool bIsIterating = false; // Safety check to avoid removals during iteration but allow index-based iteration
    };
 
    ENGINE_API FSubsystemCollectionBase(UClass* InBaseType);
 
    ENGINE_API FSubsystemCollectionBase();
    
    ENGINE_API virtual ~FSubsystemCollectionBase();
 
    ENGINE_API USubsystem* GetSubsystemInternal(UClass* SubsystemClass) const;
 
    // Fetch a list of subsystems that derive from the given class, populating the cache if necessary
    ENGINE_API FSubsystemArray& FindAndPopulateSubsystemArrayInternal(UClass* SubsystemClass) const;
 
    ENGINE_API TArray<USubsystem*> GetSubsystemArrayCopy(UClass* SubsystemClass) const;
 
    ENGINE_API void ForEachSubsystem(TFunctionRef<void(USubsystem*)> Operation) const;
 
    ENGINE_API void ForEachSubsystemOfClass(UClass* SubsystemClass, TFunctionRef<void(USubsystem*)> Operation) const;
 
    ENGINE_API void RemoveSubsystemsInPackages(TConstArrayView<UPackage*> Packages);
 
private:
    ENGINE_API USubsystem* AddAndInitializeSubsystem(UClass* SubsystemClass);
 
    ENGINE_API void RemoveAndDeinitializeSubsystem(USubsystem* Subsystem);
 
    TMap<TObjectPtr<UClass>, TObjectPtr<USubsystem>> SubsystemMap;
 
    mutable TMap<UClass*, TUniquePtr<FSubsystemArray>> SubsystemArrayMap;
 
    UClass* BaseType;
 
    UObject* Outer;
 
    bool bPopulating;
    mutable bool bIterating = false; // True if iterating over SubsystemMap
 
    FDelegateHandle ModulesUnloadedHandle;
 
private:
    friend class FSubsystemModuleWatcher;
 
    static ENGINE_API void AddAllInstances(UClass* SubsystemClass);
 
    static ENGINE_API void RemoveAllInstances(UClass* SubsystemClass);
};
 
template<typename TBaseType>
class FSubsystemCollection : public FSubsystemCollectionBase, public FGCObject
{
public:
    template <typename TSubsystemClass>
    TSubsystemClass* GetSubsystem(const TSubclassOf<TSubsystemClass>& SubsystemClass) const
    {
        static_assert(TIsDerivedFrom<TSubsystemClass, TBaseType>::IsDerived, "TSubsystemClass must be derived from TBaseType");
 
        // A static cast is safe here because we know SubsystemClass derives from TSubsystemClass if it is not null
        return static_cast<TSubsystemClass*>(GetSubsystemInternal(SubsystemClass));
    }
 
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetSubsystemArrayCopy(const TSubclassOf<TSubsystemClass>& SubsystemClass) const
    {
        // Force a compile time check that TSubsystemClass derives from TBaseType, the internal code only enforces it's a USubsystem
        TSubclassOf<TBaseType> SubsystemBaseClass = SubsystemClass;
 
        FSubsystemArray& Array = FindAndPopulateSubsystemArrayInternal(SubsystemBaseClass);
        return TArray<TSubsystemClass*>(reinterpret_cast<TSubsystemClass**>(Array.Subsystems.GetData()), Array.Subsystems.Num());
    }
 
    void ForEachSubsystem(TFunctionRef<void(TBaseType*)> Operation, const TSubclassOf<TBaseType>& SubsystemClass = {}) const
    {
        // Force a compile time check that TSubsystemClass derives from TBaseType, the internal code only enforces it's a USubsystem
        ForEachSubsystemOfClass(SubsystemClass , [Operation=MoveTemp(Operation)](USubsystem* Subsystem){
            Operation(CastChecked<TBaseType>(Subsystem));
        });
    }
 
    /* FGCObject Interface */
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override
    {
        FSubsystemCollectionBase::AddReferencedObjects(nullptr, Collector);
    }
 
    virtual FString GetReferencerName() const override
    {
        return TEXT("FSubsystemCollection");
    }
    
public:
 
    FSubsystemCollection()
        : FSubsystemCollectionBase(TBaseType::StaticClass())
    {
    }
};
 
template<typename TBaseType>
class FObjectSubsystemCollection : public FSubsystemCollectionBase
{
public:
    template <typename TSubsystemClass>
    TSubsystemClass* GetSubsystem(const TSubclassOf<TSubsystemClass>& SubsystemClass) const
    {
        static_assert(TIsDerivedFrom<TSubsystemClass, TBaseType>::IsDerived, "TSubsystemClass must be derived from TBaseType");
 
        // A static cast is safe here because we know SubsystemClass derives from TSubsystemClass if it is not null
        return static_cast<TSubsystemClass*>(GetSubsystemInternal(SubsystemClass));
    }
 
    template <typename TSubsystemClass>
    TArray<TSubsystemClass*> GetSubsystemArrayCopy(const TSubclassOf<TSubsystemClass>& SubsystemClass) const
    {
        // Force a compile time check that TSubsystemClass derives from TBaseType, the internal code only enforces it's a USubsystem
        TSubclassOf<TBaseType> SubsystemBaseClass = SubsystemClass;
 
        FSubsystemArray& Array = FindAndPopulateSubsystemArrayInternal(SubsystemBaseClass);
        return TArray<TSubsystemClass*>(reinterpret_cast<TSubsystemClass**>(Array.Subsystems.GetData()), Array.Subsystems.Num());
    }
 
    void ForEachSubsystem(TFunctionRef<void(TBaseType*)> Operation, const TSubclassOf<TBaseType>& SubsystemClass = {}) const
    {
        ForEachSubsystemOfClass(SubsystemClass, [Operation=MoveTemp(Operation)](USubsystem* Subsystem){
            Operation(CastChecked<TBaseType>(Subsystem));
        });
    }
 
    template <typename TSubsystemInterface>
    void ForEachSubsystemWithInterface(TFunctionRef<void(TBaseType*)> Operation) const
    {
        UClass* SubsystemInterfaceClass = TSubsystemInterface::StaticClass();
        ForEachSubsystemOfClass(SubsystemInterfaceClass, [Operation = MoveTemp(Operation)](USubsystem* Subsystem)
        {
            Operation(CastChecked<TBaseType>(Subsystem));
        });
    }
 
public:
 
    FObjectSubsystemCollection()
        : FSubsystemCollectionBase(TBaseType::StaticClass())
    {
    }
};