refactor FPropertyTypeName

Author: moritz-h

libsave/include/SatisfactorySave/GameTypes/Properties/Base/PropertyTag.h

@@ -18,7 +18,7 @@ namespace SatisfactorySave {
     };
 
     struct SATISFACTORYSAVE_API PropertyTag {
-        FPropertyTypeName TypeName;
+        FPropertyTypeName_Data TypeName;
         FName Name;
         FName Type;
         int32_t Size = 0;
@@ -38,6 +38,7 @@ namespace SatisfactorySave {
 
         void serialize(Archive& ar);
 
-        void SetType(FPropertyTypeName InFullType);
+    protected:
+        void SetType();
     };
 } // namespace SatisfactorySave

libsave/include/SatisfactorySave/GameTypes/UE/CoreUObject/UObject/PropertyTypeName.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <span>
 #include <vector>
 
 #include "../../../../IO/Archive/Archive.h"
@@ -20,29 +21,38 @@ namespace SatisfactorySave {
     };
 
     class SATISFACTORYSAVE_API FPropertyTypeName {
-    public:
-        std::vector<FPropertyTypeNameNode> Nodes;
+    protected:
+        std::span<FPropertyTypeNameNode> Nodes;
 
-        void serialize(Archive& ar) {
-            if (ar.isIArchive()) {
-                Nodes.clear();
-                int32_t Remaining = 1;
-                do {
-                    FPropertyTypeNameNode& Node = Nodes.emplace_back();
-                    ar << Node;
-                    Remaining += Node.InnerCount - 1;
-                } while (Remaining > 0);
-            } else {
-                for (auto& Node : Nodes) {
-                    ar << Node;
-                }
-            }
+    public:
+        [[nodiscard]] inline bool IsEmpty() const {
+            return Nodes.empty();
         }
 
         [[nodiscard]] inline const FName& GetName() const {
             return Nodes[0].Name;
         }
 
+        [[nodiscard]] inline FPropertyTypeName GetParameter(int32_t ParamIndex) const {
+            const FPropertyTypeNameNode& First = Nodes[0];
+            if (ParamIndex < 0 || ParamIndex >= First.InnerCount) {
+                return {};
+            }
+            int32_t ParamIdxPtr = 1;
+            for (int32_t Skip = ParamIndex; Skip > 0; Skip--, ParamIdxPtr++) {
+                Skip += Nodes[ParamIdxPtr].InnerCount;
+            }
+            int32_t Remaining = Nodes[ParamIdxPtr].InnerCount;
+            int Length = 1;
+            while (Remaining > 0) {
+                Remaining += Nodes[ParamIdxPtr + Length].InnerCount - 1;
+                Length++;
+            }
+            FPropertyTypeName Param;
+            Param.Nodes = Nodes.subspan(ParamIdxPtr, Length);
+            return Param;
+        }
+
         [[nodiscard]] inline FName GetParameterName(int32_t ParamIndex) const {
             const FPropertyTypeNameNode& First = Nodes[0];
             if (ParamIndex < 0 || ParamIndex >= First.InnerCount) {
@@ -55,4 +65,46 @@ namespace SatisfactorySave {
             return Nodes[ParamIdxPtr].Name;
         }
     };
+
+    /**
+     * FPropertyTypeName_Data is a custom wrapper to actually hold the FPropertyTypeName data. Unreal internally
+     * instead uses a global table, but here data should be held locally.
+     */
+    class SATISFACTORYSAVE_API FPropertyTypeName_Data : public FPropertyTypeName {
+    protected:
+        std::vector<FPropertyTypeNameNode> Nodes_Data;
+
+    public:
+        FPropertyTypeName_Data() = default;
+        FPropertyTypeName_Data(const FPropertyTypeName_Data& other) : Nodes_Data(other.Nodes_Data) {
+            Nodes = Nodes_Data;
+        }
+        FPropertyTypeName_Data& operator=(const FPropertyTypeName_Data& other) {
+            if (this != &other) {
+                Nodes_Data = other.Nodes_Data;
+                Nodes = Nodes_Data;
+            }
+            return *this;
+        }
+        FPropertyTypeName_Data(FPropertyTypeName_Data&&) noexcept = default;
+        FPropertyTypeName_Data& operator=(FPropertyTypeName_Data&&) noexcept = default;
+
+        void serialize(Archive& ar) {
+            if (ar.isIArchive()) {
+                Nodes_Data.clear();
+                int32_t Remaining = 1;
+                do {
+                    FPropertyTypeNameNode& Node = Nodes_Data.emplace_back();
+                    ar << Node;
+                    Remaining += Node.InnerCount - 1;
+                } while (Remaining > 0);
+                // Update Nodes span.
+                Nodes = Nodes_Data;
+            } else {
+                for (auto& Node : Nodes_Data) {
+                    ar << Node;
+                }
+            }
+        }
+    };
 } // namespace SatisfactorySave

libsave/src/GameTypes/Properties/Base/PropertyTag.cpp

@@ -19,7 +19,7 @@ void SatisfactorySave::PropertyTag::serialize(Archive& ar) {
     if (ar.getSaveVersion() >= 53) {
         ar << TypeName;
         if (ar.isIArchive()) {
-            SetType(TypeName);
+            SetType();
         }
 
         if (ar.isOArchive()) {
@@ -103,8 +103,7 @@ void SatisfactorySave::PropertyTag::serialize(Archive& ar) {
     }
 }
 
-void SatisfactorySave::PropertyTag::SetType(FPropertyTypeName InFullType) {
-    TypeName = std::move(InFullType);
+void SatisfactorySave::PropertyTag::SetType() {
     Type = TypeName.GetName();
 
     if (Type.Number == /*NAME_NO_NUMBER_INTERNAL*/ 0) {