Change descriptors to use polymorphism and unique_ptr instead of variant to avoid incomplete types

Author: EmilDohne

CMakeLists.txt

@@ -24,6 +24,7 @@ if (PSAPI_BUILD_PYTHON)
 endif()
 
 
+
 # Build setup
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 set (CMAKE_CXX_STANDARD 20)

PhotoshopAPI/src/Core/Struct/DescriptorStructure.cpp

@@ -199,7 +199,7 @@ namespace Descriptors
 		}
 		else if (osTypeEnum == Impl::OSTypes::String)
 		{
-			return construct_descriptor<UnicodeString_Wrapper>(key, ostype);
+			return construct_descriptor<UnicodeString_Wrapper>(document, key, ostype);
 		}
 		else
 		{
@@ -271,15 +271,15 @@ namespace Descriptors
 		{
 			return;
 		}
-		m_DescriptorItems.push_back(item);
+		m_DescriptorItems.push_back(std::move(item));
 	}
 
 
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
 	void KeyValueMixin::insert(std::string key, std::unique_ptr<DescriptorBase> value) noexcept
 	{
-		insert(std::make_pair(key, value));
+		insert(std::make_pair(key, std::move(value)));
 	}
 
 	// ---------------------------------------------------------------------------------------------------------------------
@@ -328,15 +328,15 @@ namespace Descriptors
 			valueRef = std::move(item.second);
 			return;
 		}
-		m_DescriptorItems.push_back(item);
+		m_DescriptorItems.push_back(std::move(item));
 	}
 
 
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
 	void KeyValueMixin::insert_or_assign(std::string key, std::unique_ptr<DescriptorBase> value) noexcept
 	{
-		insert_or_assign(std::make_pair(key, value));
+		insert_or_assign(std::make_pair(key, std::move(value)));
 	}
 
 
@@ -397,6 +397,18 @@ namespace Descriptors
 	}
 
 
+	// ---------------------------------------------------------------------------------------------------------------------
+	// ---------------------------------------------------------------------------------------------------------------------
+	KeyValueMixin& KeyValueMixin::operator=(KeyValueMixin&& other) noexcept
+	{
+
+		if (this != &other) 
+		{
+			this->m_DescriptorItems = std::move(other.m_DescriptorItems);
+		}
+		return *this;
+	}
+
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
 	Property::Property(std::string key, std::vector<char> osKey, std::string name, std::string classID, std::string keyID)
@@ -1134,10 +1146,10 @@ namespace Descriptors
 
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
-	List::List(std::string key, std::vector<char> osKey, std::vector<DescriptorVariant> items)
+	List::List(std::string key, std::vector<char> osKey, std::vector<std::unique_ptr<DescriptorBase>> items)
 		: DescriptorBase(key, osKey)
 	{
-		m_Items = items;
+		m_Items = std::move(items);
 	}
 
 
@@ -1444,7 +1456,7 @@ namespace Descriptors
 	// ---------------------------------------------------------------------------------------------------------------------
 	bool double_Wrapper::operator==(const double_Wrapper& other) const
 	{
-		return this->m_Value == other.m_Value
+		return this->m_Value == other.m_Value;
 	}
 
 
@@ -1458,22 +1470,34 @@ namespace Descriptors
 		};
 	}
 
+
+	// ---------------------------------------------------------------------------------------------------------------------
+	// ---------------------------------------------------------------------------------------------------------------------
+	double_Wrapper::double_Wrapper(double value)
+	{
+		m_Value = value; DescriptorBase::m_OSKey = Impl::descriptorKeys.at(Impl::OSTypes::Double);
+	}
 
+
 	// ---------------------------------------------------------------------------------------------------------------------
 	// ---------------------------------------------------------------------------------------------------------------------
 	void int32_t_Wrapper::read(File& document)
 	{
 		m_Value = ReadBinaryData<int32_t>(document);
 	}
 
+	// ---------------------------------------------------------------------------------------------------------------------
+	// ---------------------------------------------------------------------------------------------------------------------
 	void int32_t_Wrapper::write(File& document) const
 	{
 		WriteBinaryData<int32_t>(document, m_Value);
 	}
 
+	// ---------------------------------------------------------------------------------------------------------------------
+	// ---------------------------------------------------------------------------------------------------------------------
 	bool int32_t_Wrapper::operator==(const int32_t_Wrapper& other) const
 	{
-		return this->m_Value == other.m_Value
+		return this->m_Value == other.m_Value;
 	}
 
 	json_ordered int32_t_Wrapper::to_json() const
@@ -1484,6 +1508,11 @@ namespace Descriptors
 		};
 	}
 
+	int32_t_Wrapper::int32_t_Wrapper(int32_t value)
+	{
+		m_Value = value; DescriptorBase::m_OSKey = Impl::descriptorKeys.at(Impl::OSTypes::Integer);
+	}
+
 	void int64_t_Wrapper::read(File& document)
 	{
 		m_Value = ReadBinaryData<int64_t>(document);
@@ -1496,17 +1525,22 @@ namespace Descriptors
 
 	bool int64_t_Wrapper::operator==(const int64_t_Wrapper& other) const
 	{
-		return this->m_Value == other.m_Value
+		return this->m_Value == other.m_Value;
 	}
 
 	json_ordered int64_t_Wrapper::to_json() const
 	{
 		return {
 					{"implementation", { {"_data_type", "int64_t"} }},
-					{ "value", value }
+					{ "value", m_Value }
 		};
 	}
 
+	int64_t_Wrapper::int64_t_Wrapper(int64_t value)
+	{
+		m_Value = value; DescriptorBase::m_OSKey = Impl::descriptorKeys.at(Impl::OSTypes::LargeInteger);
+	}
+
 	void bool_Wrapper::read(File& document)
 	{
 		m_Value = ReadBinaryData<bool>(document);
@@ -1519,18 +1553,23 @@ namespace Descriptors
 
 	bool bool_Wrapper::operator==(const bool_Wrapper& other) const
 	{
-		return this->m_Value == other.m_Value
+		return this->m_Value == other.m_Value;
 	}
 
 	json_ordered bool_Wrapper::to_json() const
 	{
 		return
 		{
 			{"implementation", { {"_data_type", "bool"} }},
-			{ "value", value }
+			{ "value", m_Value }
 		};
 	}
 
+	bool_Wrapper::bool_Wrapper(bool value)
+	{
+		m_Value = value; DescriptorBase::m_OSKey = Impl::descriptorKeys.at(Impl::OSTypes::Boolean);
+	}
+
 	void UnicodeString_Wrapper::read(File& document)
 	{
 		m_Value.read(document, 1u);
@@ -1543,18 +1582,23 @@ namespace Descriptors
 
 	bool UnicodeString_Wrapper::operator==(const UnicodeString_Wrapper& other) const
 	{
-		return this->m_Value == other.m_Value
+		return this->m_Value == other.m_Value;
 	}
 
 	json_ordered UnicodeString_Wrapper::to_json() const
 	{
 		return
 		{
 			{"implementation", { {"_data_type", "UnicodeString"} }},
-			{ "value", value.getString()}
+			{ "value", m_Value.getString()}
 		};
 	}
 
+	UnicodeString_Wrapper::UnicodeString_Wrapper(UnicodeString value)
+	{
+		m_Value = value; DescriptorBase::m_OSKey = Impl::descriptorKeys.at(Impl::OSTypes::String);
+	}
+
 }
 
 PSAPI_NAMESPACE_END