Update to version 1.1. Optimization and security improved. Tag support added.

Author: Pavreally

Plugins/AsyncDataAssetManager/AsyncDataAssetManager.uplugin

@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
 	"Version": 1,
-	"VersionName": "1.0",
+	"VersionName": "1.1",
 	"FriendlyName": "Async Data Asset Manager",
 	"Description": "Asynchronous management of data assets.",
 	"Category": "Async Technologies",

Plugins/AsyncDataAssetManager/Content/DemoFiles/BP_GameMode_ADAM_demo.uasset

@@ -7,7 +7,7 @@
 #include "AsyncTechnologiesSettings.h"
 
 // Initialize subsystem
-void UAsyncDataAssetManagerSubsystem::Initialize(FSubsystemCollectionBase &Collection)
+void UAsyncDataAssetManagerSubsystem::Initialize(FSubsystemCollectionBase& Collection)
 {
 	Super::Initialize(Collection);
 
@@ -24,13 +24,13 @@ void UAsyncDataAssetManagerSubsystem::Deinitialize()
 {
 	Super::Deinitialize();
 
-	DataADAM.Empty();
+	UnloadAllADAM(true);
 
 	OnLoadedADAM.Clear();
 }
 
 // BlueprintCallable Function. Asynchronous loading of Primary Data Asset
-void UAsyncDataAssetManagerSubsystem::LoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, TSoftObjectPtr<UPrimaryDataAsset> &ReturnPrimaryDataAsset)
+void UAsyncDataAssetManagerSubsystem::LoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset)
 {
 	if (PrimaryDataAsset.IsNull())
 	{
@@ -49,14 +49,14 @@ void UAsyncDataAssetManagerSubsystem::LoadADAM(TSoftObjectPtr<UPrimaryDataAsset>
 	}
 
 	// Add in array ADAM and async load
-	AddToADAM(PrimaryDataAsset);
+	AddToADAM(PrimaryDataAsset, Tag);
 
 	// Return the value of a soft link
 	ReturnPrimaryDataAsset = PrimaryDataAsset;
 }
 
 // BlueprintCallable Function. Asynchronous loading of an array of Primary Data Asset
-void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, TArray<TSoftObjectPtr<UPrimaryDataAsset>> &ReturnPrimaryDataAssets)
+void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, FName Tag, TArray<TSoftObjectPtr<UPrimaryDataAsset>>& ReturnPrimaryDataAssets)
 {
 	if (PrimaryDataAssets.IsEmpty())
 	{
@@ -77,15 +77,15 @@ void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrima
 		}
 
 		// Add in array ADAM and async load
-		AddToADAM(DataAsset);
+		AddToADAM(DataAsset, Tag);
 	}
 
 	// Return an array of soft links
 	ReturnPrimaryDataAssets = PrimaryDataAssets;
 }
 
 // Add Data Asset to the ADAM array and load asynchronously
-void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset)
+void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag)
 {
 	// Create a delegate
 	FStreamableManager& StreamableManager = UAssetManager::GetStreamableManager();
@@ -110,6 +110,7 @@ void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset
 	FMemoryADAM NewDataAsset;
 	NewDataAsset.SoftReference = PrimaryDataAsset;
 	NewDataAsset.MemoryReference = DataAssetHandle;
+	NewDataAsset.Tag = Tag;
 	DataADAM.Add(NewDataAsset);
 }
 
@@ -131,7 +132,7 @@ void UAsyncDataAssetManagerSubsystem::OnLoaded(TSoftObjectPtr<UPrimaryDataAsset>
 }
 
 // Loading a Data Asset without storing it in memory
-void UAsyncDataAssetManagerSubsystem::FastLoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, TSoftObjectPtr<UPrimaryDataAsset> &ReturnPrimaryDataAsset)
+void UAsyncDataAssetManagerSubsystem::FastLoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset)
 {
 	if (PrimaryDataAsset.IsNull())
 	{
@@ -178,14 +179,17 @@ void UAsyncDataAssetManagerSubsystem::UnloadADAM(TSoftObjectPtr<UPrimaryDataAsse
 		return;
 	}
 
+	// Deletion of target data from ADAM if deletion by tag was not triggered.
 	int32 TargetIndex = GetIndexDataADAM(PrimaryDataAsset);
 
-	RemoveFromADAM(TargetIndex, ForcedUnload);
+	if (TargetIndex == -1) return;
 
 	if (EnableLog)
 	{
 		UE_LOG(LogTemp, Display, TEXT("ADAM: Unload data asset \"%s\" (index: %d)"), *PrimaryDataAsset.GetAssetName(), TargetIndex);
 	}
+
+	RemoveFromADAM(TargetIndex, ForcedUnload);
 }
 
 // BlueprintCallable Function. Unload all items from the ADAM collection
@@ -197,14 +201,36 @@ void UAsyncDataAssetManagerSubsystem::UnloadAllADAM(bool ForcedUnload)
 		return;
 	}
 
+	// Remove all from ADAM
 	for (int32 i = DataADAM.Num() - 1; i >= 0; i--)
 	{
-		RemoveFromADAM(i, ForcedUnload);
-
 		if (EnableLog)
 		{
 			UE_LOG(LogTemp, Display, TEXT("ADAM: Unload data asset (index: %d)"), i);
 		}
+
+		RemoveFromADAM(i, ForcedUnload);
+	}
+}
+
+// Unload all data assets with the specified tag from the array and memory. Unloading in descending order.
+void UAsyncDataAssetManagerSubsystem::UnloadAllTagsADAM(FName Tag, bool ForcedUnload)
+{
+	// Remove of all data with a similar target tag
+	if (Tag != "None")
+	{
+		for (int32 i = DataADAM.Num() - 1; i >= 0; i--)
+		{
+			if (DataADAM[i].Tag == Tag)
+			{
+				if (EnableLog)
+				{
+					UE_LOG(LogTemp, Display, TEXT("ADAM: Unload data asset \"%s\" (index: %d)"), *DataADAM[i].SoftReference.GetAssetName(), i);
+				}
+
+				RemoveFromADAM(i, ForcedUnload);
+			}
+		}
 	}
 }
 
@@ -231,25 +257,50 @@ void UAsyncDataAssetManagerSubsystem::RemoveFromADAM(int32 DataAssetIndex, bool
 	}
 }
 
-// BlueprintCallable Function. Return the length of the main array of the subsystem - DataADAM 
-void UAsyncDataAssetManagerSubsystem::GetDataADAM(TArray<FMirrorADAM> &MirrorDataADAM, int32 &Length)
+// BlueprintCallable Function. Returns the ADAM mirror array formed it the main array with a reference to the destructor.
+TArray<FMirrorADAM> UAsyncDataAssetManagerSubsystem::GetDataADAM()
+{
+	int32 Length = DataADAM.Num();
+	TArray<FMirrorADAM> MirrorDataADAM;
+
+	if (Length == 0) return MirrorDataADAM;
+
+	for (int32 i = 0; i < Length; i++)
+	{
+		FMirrorADAM MirrorDataAsset;
+		MirrorDataAsset.PrimaryDataAssetName = DataADAM[i].SoftReference.GetAssetName();
+		MirrorDataAsset.SoftReference = DataADAM[i].SoftReference;
+		MirrorDataAsset.Tag = DataADAM[i].Tag;
+		MirrorDataADAM.Add(MirrorDataAsset);
+	}
+
+	return MirrorDataADAM;
+}
+
+// BlueprintCallable Function. Returns an TMap that shows how many data items there are in the ADAM system for each unique tag.
+TMap<FName, int32> UAsyncDataAssetManagerSubsystem::GetCollectionByTagADAM()
 {
-	Length = DataADAM.Num();
+	TMap<FName, int32> TagCollection;
+
+	if (DataADAM.Num() == 0) return TagCollection;
 
-	if (Length >= 0)
+	for (const FMemoryADAM& Data : DataADAM)
 	{
-		for (int32 i = 0; i < Length; i++)
+		if (TagCollection.Contains(Data.Tag))
 		{
-			FMirrorADAM MirrorDataAsset;
-			MirrorDataAsset.PrimaryDataAssetName = DataADAM[i].SoftReference.GetAssetName();
-			MirrorDataAsset.SoftReference = DataADAM[i].SoftReference;
-			MirrorDataADAM.Add(MirrorDataAsset);
+			TagCollection[Data.Tag]++;
+		}
+		else
+		{
+			TagCollection.Add(Data.Tag, 1);
 		}
 	}
+
+	return TagCollection;
 }
 
 // BlueprintCallable Function. Returns a pointer to the Data Asset (ADAM) object stored in memory.
-UObject* UAsyncDataAssetManagerSubsystem::GetObjectDataADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, bool &IsValid )
+UObject* UAsyncDataAssetManagerSubsystem::GetObjectDataADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, bool& IsValid )
 {
 	if (PrimaryDataAsset.IsNull())
 	{

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Private/AsyncDataAssetManagerSubsystem.cpp

@@ -18,9 +18,13 @@ struct FMemoryADAM
 	GENERATED_USTRUCT_BODY()
 
 public:
+	UPROPERTY()
 	TSoftObjectPtr<UPrimaryDataAsset> SoftReference;
 
 	TSharedPtr<FStreamableHandle> MemoryReference;
+
+	UPROPERTY()
+	FName Tag;
 };
 
 // Designed to output information about the current storage of data assets.
@@ -35,6 +39,9 @@ struct FMirrorADAM
 
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "ADAM Subsystem")
 	TSoftObjectPtr<UPrimaryDataAsset> SoftReference;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "ADAM Subsystem")
+	FName Tag;
 };
 
 #pragma endregion STRUCTS
@@ -48,14 +55,14 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	GENERATED_BODY()
 
 public:
-	virtual void Initialize(FSubsystemCollectionBase &Collection) override;
+	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
 	virtual void Deinitialize() override;
 
 #pragma region DELEGATES
 	DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnLoadedADAM, UObject*, LoadedObject, TSoftObjectPtr<UPrimaryDataAsset>, LoadedPrimaryDataAsset);
 
 	// Indicates that the download is complete
-	UPROPERTY(BLueprintAssignable, Category = "ADAM Subsystem")
+	UPROPERTY(BlueprintAssignable, Category = "ADAM Subsystem")
 	FOnLoadedADAM OnLoadedADAM;
 
 #pragma endregion DELEGATES
@@ -71,21 +78,26 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	TArray<FString> QueueADAM;
 
 #pragma region BlueprintFunctions
-	// Async loading of a Data Asset and storing it in memory.
+	/**
+	 * Async loading of a Data Asset and storing it in memory.
+	 * @param Tag Designed for data grouping.
+	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
-	void LoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, TSoftObjectPtr<UPrimaryDataAsset> &ReturnPrimaryDataAsset);
+	void LoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset);
 
-	// Async loading of an array of Data Asset and storing each element in memory.
+	/**
+	 * Async loading of an array of Data Asset and storing each element in memory.
+	 * @param Tag Designed for data grouping.
+	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
-	void LoadArrayADAM(TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, TArray<TSoftObjectPtr<UPrimaryDataAsset>> &ReturnPrimaryDataAssets);
+	void LoadArrayADAM(TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, FName Tag, TArray<TSoftObjectPtr<UPrimaryDataAsset>>& ReturnPrimaryDataAssets);
 
 	// Loading a Data Asset without storing it in memory.
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
-	void FastLoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, TSoftObjectPtr<UPrimaryDataAsset> &ReturnPrimaryDataAsset);
+	void FastLoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset);
 
 	/**
 	 * Unload one Data Asset from array and memory.
-	 * 
 	 * @param ForcedUnload If true, the function call will stop loading the Data Asset
 	 * asynchronously and will make the target resource available for memory freeing,
 	 * on the next rubbish collection. If false, the function call will immediately clear memory from the target resource.
@@ -94,8 +106,7 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	void UnloadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, bool ForcedUnload);
 
 	/**
-	 * Unload all Data Assets from array and memory. Unloading takes place in the order of very.
-	 * 
+	 * Unload all Data Assets from array and memory. Unloading in descending order.
 	 * @param ForcedUnload If true, the function call will stop loading the Data Asset
 	 * asynchronously and will make the target resource available for memory freeing,
 	 * on the next rubbish collection. If false, the function call will immediately clear memory from the target resource.
@@ -104,17 +115,35 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	void UnloadAllADAM(bool ForcedUnload);
 
 	/**
-	 * Returns the state of the main Data ADAM array
+	 * Unload all data assets with the specified tag from the array and memory. Unloading in descending order.
+	 * @param Tag Alternative deletion option. If this value is changed, all Data Assets with the specified tag will be removed from memory.
+	 * @param ForcedUnload If true, the function call will stop loading the Data Asset
+	 * asynchronously and will make the target resource available for memory freeing,
+	 * on the next rubbish collection. If false, the function call will immediately clear memory from the target resource.
+	 */
+	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
+	void UnloadAllTagsADAM(FName Tag, bool ForcedUnload);
+
+	/**
+	 * Returns the ADAM mirror array formed it the main array with a reference to the destructor.
+	 * @return Returns a mirrored array of DataADAM.
+	 */
+	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
+	TArray<FMirrorADAM> GetDataADAM();
+
+	/**
+	 * Returns an array that shows how many data items there are in the ADAM system for each unique tag.
+	 * @return Returns the tag values and the corresponding number of Data Assets.
 	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
-	void GetDataADAM(TArray<FMirrorADAM> &MirrorDataADAM, int32 &Length);
+	TMap<FName, int32> GetCollectionByTagADAM();
 
 	/**
 	 * Returns a pointer to the Data Asset ADAM object stored in memory.
 	 * @param IsValid Returns the validity state of the object.
 	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
-	UObject* GetObjectDataADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, bool &IsValid);
+	UObject* GetObjectDataADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, bool& IsValid);
 
 	// Returns the index from the array of the ADAM data asset collection. If nothing is found returns -1.
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
@@ -134,7 +163,7 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	void RemoveFromADAM(int32 DataAssetIndex, bool ForcedUnload);
 
 	UFUNCTION()
-	void AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset);
+	void AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag);
 
 	UFUNCTION()
 	void OnLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset);

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Public/AsyncDataAssetManagerSubsystem.h

@@ -2,14 +2,20 @@
 
 # Async Data Asset Manager
 `BETA`<br><br>
-ADAM is a plugin for Unreal Engine 5 that adds a subsystem for managing asynchronous loading and unloading of Data Assets. This subsystem simplifies the approach to data management, which can be used in both Blueprint and C++.
+ADAM is a plugin for Unreal Engine 5 that adds a subsystem for asynchronous loading and unloading of Data Assets. This subsystem simplifies data management and can be used in both Blueprints and C++.
 
-<br><br><i>(The plugin has been pre-packaged only for Win64 and Android)</i>
+<br>
+> [!NOTE]
+> The plugin has been pre-packaged only for Win64 and Android.
 
 # Latest Updates
-`Version 1.0`
+`Version 1.1`
 - Build version for Unreal Engine 5.5.
-- Release experimental version of the plugin.
+- Refactoring and optimization of the code.
+- Enhanced security for memory resource management.
+- Added the ability to specify a tag for uploaded files.
+- Added a new function `UnloadAllTagsADAM`, which will unload DataAssets stored in memory by the specified tag.
+- Added a new function `GetCollectionByTagADAM`, which will display a list of tags stored in the ADAM system (including default tags - NONE) and their total count.
 
 ## What it's for
 - Load and unload Data Assets asynchronously using simple functions.
@@ -19,6 +25,7 @@ ADAM is a plugin for Unreal Engine 5 that adds a subsystem for managing asynchro
 - Fast and simple management of asynchronous Data Asset loading without the need to use C++ code.
 - The ADAM subsystem supports parallel asynchronous loading of Data Assets from multiple sources, controlling random duplicate load and unload requests in real-time.
 - Supports bulk asynchronous loading of unique Data Assets.
+- Group your uploaded DataAssets using tags so that they can be unloaded at the right moment <i>(for example, this can be useful if you are uploading DataAssets in parts and want to unload them without affecting other necessary data still stored in memory)</i>.
 - Supports asynchronous loading without memory retention (e.g., if you need to immediately access data and then free up memory).
 - Disableable debug logs allow you to monitor the entire asynchronous data management process. Plugin settings are located in `Project Settings > Plugins > Async Technologies - ADAM`.
 
@@ -36,4 +43,4 @@ An interactive step-by-step tutorial on how to use ADAM can be found in the file
 ![Window Manager](./_Misc/Tutorial/Tutorial_3.jpg)
 
 ## (C++) Documentaion
-All sources contain self-documenting code. C++ and BP functions are completely identical and interchangeable.
+All sources contain self-documenting code.