refactor: migrate old code

materializer/CMakeLists.txt

@@ -16,7 +16,7 @@ PRIVATE
     PluginMain.cpp
     StandaloneMain.cpp
     # Exporter
-    ExportContext.cpp
+    ExportDocument.cpp
     ExportEnvironment.cpp
     ExportScript.cpp
     # Utilities
@@ -38,9 +38,7 @@ FILES
     PluginMain.hpp
     StandaloneMain.hpp
     # Exporter
-    ExportContext.hpp
+    ExportCore.hpp
-    ExportEnvironment.hpp
-    ExportScript.hpp
     # Utilities
     Utilities.hpp
     Database.hpp
@@ -70,7 +68,7 @@ PROPERTIES
     CXX_STANDARD_REQUIRED 17
     CXX_EXTENSION OFF
 )
-# Setup MFC use
+# Setup MFC used in shared library
 set_target_properties(VSWMaterializer
 PROPERTIES
     CMAKE_MFC_FLAG 2

materializer/DataTypes.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "stdafx.hpp"
+#include "GenericDataTypes.hpp"
 
 namespace VSW::Materializer::DataTypes {
 
@@ -73,10 +74,10 @@ namespace VSW::Materializer::DataTypes {
 
 			// additional field
 			CK_ID input_obj;
-			bLinkInputOutputType input_type;
+			VSW::DataTypes::BehaviorLinkIOType input_type;
 			int input_index;
 			CK_ID output_obj;
-			bLinkInputOutputType output_type;
+			VSW::DataTypes::BehaviorLinkIOType output_type;
 			int output_index;
 		};
 
@@ -103,11 +104,11 @@ namespace VSW::Materializer::DataTypes {
 
 			//additional field
 			CK_ID input_obj;
-			pLinkInputOutputType input_type;
+			VSW::DataTypes::ParameterLinkIOType input_type;
 			BOOL input_is_bb;
 			int input_index;
 			CK_ID output_obj;
-			pLinkInputOutputType output_type;
+			VSW::DataTypes::ParameterLinkIOType output_type;
 			BOOL output_is_bb;
 			int output_index;
 		};
@@ -133,9 +134,37 @@ namespace VSW::Materializer::DataTypes {
 			CK_ID parent;
 		};
 
+		class DataCache {
+		public:
+			DataCache() :
+				script(), behavior(),
+				bIn(), bOut(), bLink(),
+				pOper(),
+				pIn(), pOut(), pLocal(), pAttr(), pTarget(), pLink(),
+				eLink(),
+				data() {}
+			~DataCache() {}
+
+		public:
+			Table_script script;
+			Table_behavior behavior;
+			Table_bIn bIn;
+			Table_bOut bOut;
+			Table_pIn pIn;
+			Table_pOut pOut;
+			Table_bLink bLink;
+			Table_pLocal pLocal;
+			Table_pAttr pAttr;
+			Table_pLink pLink;
+			Table_pOper pOper;
+			Table_eLink eLink;
+			Table_pTarget pTarget;
+			Table_data data;
+		};
+
 	}
 
-	namespace Context {
+	namespace Document {
 
 		struct Table_msg {
 			CKMessageType index;
@@ -149,39 +178,49 @@ namespace VSW::Materializer::DataTypes {
 			std::string classtype;
 		};
 
+		class DataCache {
+		public:
+			DataCache() : msg(), obj() {}
+			~DataCache() {}
+
+		public:
+			Table_msg msg;
+			Table_obj obj;
+		};
+
 	}
 
 	namespace Environment {
 
 		struct Table_op {
-			CK_PARAMETEROPERATION funcPtr;
+			std::string func_ptr;
-			std::string in1_guid;
+			int64_t in1_guid;
-			std::string in2_guid;
+			int64_t in2_guid;
-			std::string out_guid;
+			int64_t out_guid;
-			std::string op_guid;
+			int64_t op_guid;
 			std::string op_name;
 			CKOperationType op_code;
 		};
 
 		struct Table_param {
 			CKParameterType index;
-			std::string guid;
+			int64_t guid;
-			std::string derived_from;
+			int64_t derived_from;
 			std::string type_name;
 			int default_size;
-			CK_PARAMETERCREATEDEFAULTFUNCTION func_CreateDefault;
+			std::string func_CreateDefault;
-			CK_PARAMETERDELETEFUNCTION func_Delete;
+			std::string func_Delete;
-			CK_PARAMETERSAVELOADFUNCTION func_SaveLoad;
+			std::string func_SaveLoad;
-			CK_PARAMETERCHECKFUNCTION func_Check;
+			std::string func_Check;
-			CK_PARAMETERCOPYFUNCTION func_Copy;
+			std::string func_Copy;
-			CK_PARAMETERSTRINGFUNCTION func_String;
+			std::string func_String;
-			CK_PARAMETERUICREATORFUNCTION func_UICreator;
+			std::string func_UICreator;
 			int creator_dll_index;
 			int creator_plugin_index;
 			CKDWORD dw_param;
 			CKDWORD dw_flags;
 			CKDWORD cid;
-			std::string saver_manager;
+			int64_t saver_manager;
 		};
 
 		struct Table_attr {
@@ -201,24 +240,43 @@ namespace VSW::Materializer::DataTypes {
 			int plugin_index;
 			std::string category;
 			CKBOOL active;
-			std::string guid;
+			int64_t guid;
 			std::string desc;
 			std::string author;
 			std::string summary;
 			DWORD version;
-			CK_INITINSTANCEFCT func_init;
+			std::string func_init;
-			CK_EXITINSTANCEFCT func_exit;
+			std::string func_exit;
 		};
 
+#if defined(VIRTOOLS_21)
+		using GenericVarType_t = int;
+#else
+		using GenericVarType_t = CKVariableManager::Variable::Type;
+#endif
 		struct Table_variable {
 			std::string name;
 			std::string desciption;
 			XWORD flags;
-			UNIVERSAL_VAR_TYPE type;
+			GenericVarType_t type;
 			std::string representation;
 			std::string data;
 		};
 
+		class DataCache {
+		public:
+			DataCache() :
+				op(), param(), attr(), plugin(), variable() {}
+			~DataCache() {}
+
+		public:
+			Table_op op;
+			Table_param param;
+			Table_attr attr;
+			Table_plugin plugin;
+			Table_variable variable;
+		};
+
 	}
 
 }

materializer/Database.cpp

@@ -1,5 +1,6 @@
 #include "Database.hpp"
 #include <stdexcept>
+#include <type_traits>
 
 namespace VSW::Materializer::Database {
 
@@ -10,6 +11,28 @@ namespace VSW::Materializer::Database {
 if (errcode != SQLITE_OK) return false;
 #define END_SAFE_SQL_EXEC }
 
+	/// @brief 
+	/// Check database connection first. 
+	/// Create index variables for sqlite prepared statement binding use. 
+	/// Fetch and reset prepared statement
+#define BEGIN_WRITER(stmt_str) if (!this->IsValid()) throw std::runtime_error("write on disconnected database."); \
+int argument_index = 1; \
+sqlite3_stmt* stmt = GetStmt(stmt_str); \
+sqlite3_reset(stmt);
+	/// @brief Wrapper of binding function calling.
+#define WRITER_BIND(eval) if ((eval) != SQLITE_OK) goto failed;
+	/// @brief Get auto incresement index during binding.
+#define WRITER_INDEX (argument_index++)
+	/// @brief Get prepared statement during binding.
+#define WRITER_STMT (stmt)
+	/// @brief 
+	/// Sumbit binded prepared statement.
+	/// Binding error process.
+#define END_WRITER if (sqlite3_step(stmt) == SQLITE_OK) return; \
+failed: throw std::runtime_error("fail to bind value for prepared statement.");
+
+#define REVEAL_ENUM(enum_val) static_cast<std::underlying_type_t<decltype(enum_val)>>(enum_val)
+
 #pragma endregion
 
 #pragma region Abstract Database
@@ -153,16 +176,159 @@ if (errcode != SQLITE_OK) return false;
 		return true;
 	}
 
+	void ScriptDatabase::Write(const DataTypes::Script::Table_script& data) {
+		BEGIN_WRITER("INSERT INTO [script] VALUES (?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.host_name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.behavior));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_behavior& data) {
+		BEGIN_WRITER("INSERT INTO [script_behavior] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.type));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.proto_name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.proto_guid.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.flags));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.priority));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.version));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.pin_count.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_bIn& data) {
+		BEGIN_WRITER("INSERT INTO [script_bIn] VALUES (?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_bOut& data) {
+		BEGIN_WRITER("INSERT INTO [script_bOut] VALUES (?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pIn& data) {
+		BEGIN_WRITER("INSERT INTO [script_pIn] VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.direct_source));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.shared_source));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pOut& data) {
+		BEGIN_WRITER("INSERT INTO [script_pOut] VALUES (?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_bLink& data) {
+		BEGIN_WRITER("INSERT INTO [script_bLink] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.delay));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_obj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.input_type)));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_obj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.output_type)));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pLocal& data) {
+		BEGIN_WRITER("INSERT INTO [script_pLocal] VALUES (?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.is_setting));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pAttr& data) {
+		BEGIN_WRITER("INSERT INTO [script_pAttr] VALUES (?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pLink& data) {
+		BEGIN_WRITER("INSERT INTO [script_pLink] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_obj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.input_type)));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_is_bb));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.input_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_obj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, REVEAL_ENUM(data.output_type)));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_is_bb));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.output_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pOper& data) {
+		BEGIN_WRITER("INSERT INTO [script_pOper] VALUES (?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.op.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.op_guid.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_eLink& data) {
+		BEGIN_WRITER("INSERT INTO [script_eLink] VALUES (?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.export_obj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.internal_obj));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.is_in));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_pTarget& data) {
+		BEGIN_WRITER("INSERT INTO [script_pTarget] VALUES (?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.thisobj));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_guid.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.direct_source));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.shared_source));
+		END_WRITER;
+	}
+	void ScriptDatabase::Write(const DataTypes::Script::Table_data& data) {
+		BEGIN_WRITER("INSERT INTO [data] VALUES (?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.field.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.data.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.parent));
+		END_WRITER;
+	}
+
 #pragma endregion
 
-#pragma region Context Database
+#pragma region Document Database
 
-	ContextDatabase::ContextDatabase(const YYCC::yycc_u8string_view& file) :
+	DocumentDatabase::DocumentDatabase(const YYCC::yycc_u8string_view& file) :
 		AbstractDatabase(file) {}
 
-	ContextDatabase::~ContextDatabase() {}
+	DocumentDatabase::~DocumentDatabase() {}
 
-	bool ContextDatabase::PostOpen() {
+	bool DocumentDatabase::PostOpen() {
 		// initialize table
 		BEGIN_SAFE_SQL_EXEC;
 		SAFE_SQL_EXEC("begin;");
@@ -176,11 +342,26 @@ if (errcode != SQLITE_OK) return false;
 		return true;
 	}
 
-	bool ContextDatabase::PreClose() {
+	bool DocumentDatabase::PreClose() {
 		// do nothing
 		return true;
 	}
 
+	void DocumentDatabase::Write(const DataTypes::Document::Table_msg& data) {
+		BEGIN_WRITER("INSERT INTO [msg] VALUES (?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		END_WRITER;
+	}
+	void DocumentDatabase::Write(const DataTypes::Document::Table_obj& data) {
+		BEGIN_WRITER("INSERT INTO [obj] VALUES (?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.id));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.classid));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.classtype.c_str(), -1, SQLITE_TRANSIENT));
+		END_WRITER;
+	}
+
 #pragma endregion
 
 #pragma region Environment Database
@@ -212,6 +393,78 @@ if (errcode != SQLITE_OK) return false;
 		return true;
 	}
 
+	void EnvironmentDatabase::Write(const DataTypes::Environment::Table_op& data) {
+		BEGIN_WRITER("INSERT INTO [op] VALUES (?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_ptr.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.in1_guid));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.in2_guid));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.out_guid));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.op_guid));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.op_name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.op_code));
+		END_WRITER;
+	}
+	void EnvironmentDatabase::Write(const DataTypes::Environment::Table_param& data) {
+		BEGIN_WRITER("INSERT INTO [param] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.guid));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.derived_from));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.type_name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.default_size));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_CreateDefault.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_Delete.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_SaveLoad.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_Check.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_Copy.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_String.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_UICreator.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.creator_dll_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.creator_plugin_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.dw_param));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.dw_flags));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.cid));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.saver_manager));
+		END_WRITER;
+	}
+	void EnvironmentDatabase::Write(const DataTypes::Environment::Table_attr& data) {
+		BEGIN_WRITER("INSERT INTO [attr] VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.category_index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.category_name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.flags));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.param_index));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.compatible_classid));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.default_value.c_str(), -1, SQLITE_TRANSIENT));
+		END_WRITER;
+	}
+	void EnvironmentDatabase::Write(const DataTypes::Environment::Table_plugin& data) {
+		BEGIN_WRITER("INSERT INTO [plugin] VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.dll_index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.dll_name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.plugin_index));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.category.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.active));
+		WRITER_BIND(sqlite3_bind_int64(WRITER_STMT, WRITER_INDEX, data.guid));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.desc.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.author.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.summary.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.version));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_init.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.func_exit.c_str(), -1, SQLITE_TRANSIENT));
+		END_WRITER;
+	}
+	void EnvironmentDatabase::Write(const DataTypes::Environment::Table_variable& data) {
+		BEGIN_WRITER("INSERT INTO [variable] VALUES (?, ?, ?, ?, ?, ?)");
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.name.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.desciption.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.flags));
+		WRITER_BIND(sqlite3_bind_int(WRITER_STMT, WRITER_INDEX, data.type));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.representation.c_str(), -1, SQLITE_TRANSIENT));
+		WRITER_BIND(sqlite3_bind_text(WRITER_STMT, WRITER_INDEX, data.data.c_str(), -1, SQLITE_TRANSIENT));
+		END_WRITER;
+	}
+
 #pragma endregion
 
 }

materializer/Database.hpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "stdafx.hpp"
+#include "DataTypes.hpp"
 #include <sqlite3.h>
 #include <map>
 
@@ -55,24 +56,38 @@ namespace VSW::Materializer::Database {
 		virtual bool PreClose() override;
 
 	public:
-
+		void Write(const DataTypes::Script::Table_script& data);
+		void Write(const DataTypes::Script::Table_behavior& data);
+		void Write(const DataTypes::Script::Table_bIn& data);
+		void Write(const DataTypes::Script::Table_bOut& data);
+		void Write(const DataTypes::Script::Table_pIn& data);
+		void Write(const DataTypes::Script::Table_pOut& data);
+		void Write(const DataTypes::Script::Table_bLink& data);
+		void Write(const DataTypes::Script::Table_pLocal& data);
+		void Write(const DataTypes::Script::Table_pAttr& data);
+		void Write(const DataTypes::Script::Table_pLink& data);
+		void Write(const DataTypes::Script::Table_pOper& data);
+		void Write(const DataTypes::Script::Table_eLink& data);
+		void Write(const DataTypes::Script::Table_pTarget& data);
+		void Write(const DataTypes::Script::Table_data& data);
 	};
 
-	class ContextDatabase : public AbstractDatabase {
+	class DocumentDatabase : public AbstractDatabase {
 	public:
-		ContextDatabase(const YYCC::yycc_u8string_view& file);
+		DocumentDatabase(const YYCC::yycc_u8string_view& file);
-		virtual ~ContextDatabase();
+		virtual ~DocumentDatabase();
-		ContextDatabase(const ContextDatabase&) = delete;
+		DocumentDatabase(const DocumentDatabase&) = delete;
-		ContextDatabase& operator=(const ContextDatabase&) = delete;
+		DocumentDatabase& operator=(const DocumentDatabase&) = delete;
-		ContextDatabase(ContextDatabase&&) = delete;
+		DocumentDatabase(DocumentDatabase&&) = delete;
-		ContextDatabase& operator=(ContextDatabase&&) = delete;
+		DocumentDatabase& operator=(DocumentDatabase&&) = delete;
 
 	protected:
 		virtual bool PostOpen() override;
 		virtual bool PreClose() override;
 
 	public:
-
+		void Write(const DataTypes::Document::Table_msg& data);
+		void Write(const DataTypes::Document::Table_obj& data);
 	};
 
 	class EnvironmentDatabase : public AbstractDatabase {
@@ -89,7 +104,11 @@ namespace VSW::Materializer::Database {
 		virtual bool PreClose() override;
 
 	public:
-
+		void Write(const DataTypes::Environment::Table_op& data);
+		void Write(const DataTypes::Environment::Table_param& data);
+		void Write(const DataTypes::Environment::Table_attr& data);
+		void Write(const DataTypes::Environment::Table_plugin& data);
+		void Write(const DataTypes::Environment::Table_variable& data);
 	};
 
 }

materializer/ExportContext.cpp

@@ -1,5 +0,0 @@
-#include "ExportContext.hpp"
-
-namespace VSW::Materializer::ExportContext {
-
-}

materializer/ExportContext.hpp

@@ -1,6 +0,0 @@
-#pragma once
-#include "stdafx.hpp"
-
-namespace VSW::Materializer::ExportContext {
-
-}

materializer/ExportCore.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include "stdafx.hpp"
+
+namespace YYCC::Materializer {
+
+	namespace ExportScript {
+		void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path);
+	}
+
+	namespace ExportDocument {
+		void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path);
+	}
+
+	namespace ExportEnvironment {
+		void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path);
+	}
+
+}

materializer/ExportDocument.cpp

@@ -0,0 +1,12 @@
+#include "ExportCore.hpp"
+
+namespace VSW::Materializer::ExportDocument {
+
+
+
+
+	void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) {
+
+	}
+
+}

materializer/ExportEnvironment.cpp

@@ -1,5 +1,172 @@
-#include "ExportEnvironment.hpp"
+#include "ExportCore.hpp"
+#include "Database.hpp"
+#include "DataTypes.hpp"
+#include "Utilities.hpp"
+#include <vector>
 
 namespace VSW::Materializer::ExportEnvironment {
 
+	struct ExportContext {
+		ExportContext(YYCC::yycc_u8string_view& db_path) :
+			db(db_path), cache() {}
+		Database::EnvironmentDatabase db;
+		DataTypes::Environment::DataCache cache;
+	};
+
+	static void IterateParameterOperation(ExportContext& expctx, CKParameterManager* param_mgr) {
+		// prepare variables
+		std::vector<CKOperationDesc> op_list;
+		CKGUID guid;
+
+		// get the count of all supported paramter operations and iterate it.
+		int count = param_mgr->GetParameterOperationCount();
+		int listCount = 0, cacheListCount = 0;
+		for (int i = 0; i < count; i++) {
+			// fill the shared data part.
+			expctx.cache.op.op_code = i;
+			guid = param_mgr->OperationCodeToGuid(i);
+			Utilities::CopyGuid(expctx.cache.op.op_guid, guid);
+			expctx.cache.op.op_name = param_mgr->OperationCodeToName(i);
+
+			// get all sub-operation of this parameter operation.
+			// each sub-operation can have different in out parameter type
+			// and they are just grouped into the same parameter operation name.
+			int op_list_count = param_mgr->GetAvailableOperationsDesc(guid, nullptr, nullptr, nullptr, nullptr);
+			op_list.resize(static_cast<size_t>(op_list_count));
+			param_mgr->GetAvailableOperationsDesc(guid, nullptr, nullptr, nullptr, op_list.data());
+			for (const auto& op : op_list) {
+				Utilities::CopyGuid(expctx.cache.op.in1_guid, op.P1Guid);
+				Utilities::CopyGuid(expctx.cache.op.in2_guid, op.P2Guid);
+				Utilities::CopyGuid(expctx.cache.op.out_guid, op.ResGuid);
+				expctx.cache.op.func_ptr = Utilities::RelativeAddress(op.Fct);
+
+				expctx.db.Write(expctx.cache.op);
+			}
+		}
+	}
+
+	static void IterateParameter(ExportContext& expctx, CKParameterManager* param_mgr) {
+		// prepare variables
+		CKParameterTypeDesc* desc = nullptr;
+
+		// get the count of all paramter types and iterate it.
+		int count = param_mgr->GetParameterTypesCount();
+		for (int i = 0; i < count; i++) {
+			desc = param_mgr->GetParameterTypeDescription(i);
+
+			expctx.cache.param.index = desc->Index;
+			Utilities::CopyGuid(expctx.cache.param.guid, desc->Guid);
+			Utilities::CopyGuid(expctx.cache.param.derived_from, desc->DerivedFrom);
+			expctx.cache.param.type_name = desc->TypeName.CStr();
+			expctx.cache.param.default_size = desc->DefaultSize;
+			expctx.cache.param.func_CreateDefault = Utilities::RelativeAddress(desc->CreateDefaultFunction);
+			expctx.cache.param.func_Delete = Utilities::RelativeAddress(desc->DeleteFunction);
+			expctx.cache.param.func_SaveLoad = Utilities::RelativeAddress(desc->SaveLoadFunction);
+			expctx.cache.param.func_Check = Utilities::RelativeAddress(desc->CheckFunction);
+			expctx.cache.param.func_Copy = Utilities::RelativeAddress(desc->CopyFunction);
+			expctx.cache.param.func_String = Utilities::RelativeAddress(desc->StringFunction);
+			expctx.cache.param.func_UICreator = Utilities::RelativeAddress(desc->UICreatorFunction);
+			CKPluginEntry* plugin_entry = desc->CreatorDll;
+			if (plugin_entry != nullptr) {
+				expctx.cache.param.creator_dll_index = plugin_entry->m_PluginDllIndex;
+				expctx.cache.param.creator_plugin_index = plugin_entry->m_PositionInDll;
+			} else {
+				expctx.cache.param.creator_dll_index = -1;
+				expctx.cache.param.creator_plugin_index = -1;
+			}
+			expctx.cache.param.dw_param = desc->dwParam;
+			expctx.cache.param.dw_flags = desc->dwFlags;
+			expctx.cache.param.cid = desc->Cid;
+			Utilities::CopyGuid(expctx.cache.param.saver_manager, desc->Saver_Manager);
+
+			expctx.db.Write(expctx.cache.param);
+		}
+	}
+
+	static void IterateAttribute(ExportContext& expctx, CKAttributeManager* attr_mgr) {
+		// get the count of all attributes and iterate it.
+		int count = attr_mgr->GetAttributeCount();
+		for (int i = 0; i < count; i++) {
+			expctx.cache.attr.index = i;
+			expctx.cache.attr.name = attr_mgr->GetAttributeNameByType(i);
+			expctx.cache.attr.category_index = attr_mgr->GetAttributeCategoryIndex(i);
+			Utilities::CopyCKString(expctx.cache.attr.category_name, attr_mgr->GetAttributeCategory(i));
+			expctx.cache.attr.flags = attr_mgr->GetAttributeFlags(i);
+			expctx.cache.attr.param_index = attr_mgr->GetAttributeParameterType(i);
+			expctx.cache.attr.compatible_classid = attr_mgr->GetAttributeCompatibleClassId(i);
+			Utilities::CopyCKString(expctx.cache.attr.default_value, attr_mgr->GetAttributeDefaultValue(i));
+
+			expctx.db.Write(expctx.cache.attr);
+		}
+	}
+
+	static void IteratePlugin(ExportContext& expctx, CKPluginManager* plugin_mgr) {
+		// get category count and iterate them
+		int category_count = plugin_mgr->GetCategoryCount();
+		for (int i = 0; i < category_count; ++i) {
+			// get category name and set it
+			expctx.cache.plugin.category = plugin_mgr->GetCategoryName(i);
+
+			// iterate plugin within this category
+			int plugin_count = plugin_mgr->GetPluginCount(i);
+			for (int j = 0; j < plugin_count; j++) {
+				CKPluginEntry* plugin_entry = plugin_mgr->GetPluginInfo(i, j);
+				CKPluginInfo* plugin_info = &(plugin_entry->m_PluginInfo);
+				CKPluginDll* plugin_dll = plugin_mgr->GetPluginDllInfo(plugin_entry->m_PluginDllIndex);
+
+				expctx.cache.plugin.dll_index = plugin_entry->m_PluginDllIndex;
+
+				expctx.cache.plugin.dll_name = plugin_dll->m_DllFileName.CStr();
+
+				expctx.cache.plugin.plugin_index = plugin_entry->m_PositionInDll;
+				expctx.cache.plugin.active = plugin_entry->m_Active;
+
+				Utilities::CopyGuid(expctx.cache.plugin.guid, plugin_info->m_GUID);
+				expctx.cache.plugin.desc = plugin_info->m_Description.CStr();
+				expctx.cache.plugin.author = plugin_info->m_Author.CStr();
+				expctx.cache.plugin.summary = plugin_info->m_Summary.CStr();
+				expctx.cache.plugin.version = plugin_info->m_Version;
+				expctx.cache.plugin.func_init = Utilities::RelativeAddress(plugin_info->m_InitInstanceFct);
+				expctx.cache.plugin.func_exit = Utilities::RelativeAddress(plugin_info->m_ExitInstanceFct);
+
+				expctx.db.Write(expctx.cache.plugin);
+			}
+		}
+	}
+
+#if !defined(VIRTOOLS_21)
+	static void IterateVariable(ExportContext& expctx, CKVariableManager* var_mgr) {
+		// prepare variables
+		CKVariableManager::Variable* varobj = nullptr;
+		XString xstring_cache;
+
+		for (CKVariableManager::Iterator it = var_mgr->GetVariableIterator(); !it.End(); it++) {
+			varobj = it.GetVariable();
+			expctx.cache.variable.name = it.GetName();
+			Utilities::CopyCKString(expctx.cache.variable.desciption, varobj->GetDescription());
+			expctx.cache.variable.flags = varobj->GetFlags();
+			expctx.cache.variable.type = varobj->GetType();
+			Utilities::CopyCKString(expctx.cache.variable.representation, varobj->GetRepresentation());
+			varobj->GetStringValue(xstring_cache);
+			expctx.cache.variable.data = xstring_cache.CStr();
+
+			expctx.db.Write(expctx.cache.variable);
+		}
+	}
+#endif
+
+	void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) {
+		// create database and data cache in context
+		ExportContext expctx(db_path);
+
+		// export environment one by one
+		IterateParameterOperation(expctx, ctx->GetParameterManager());
+		IterateParameter(expctx, ctx->GetParameterManager());
+		IterateAttribute(expctx, ctx->GetAttributeManager());
+		IteratePlugin(expctx, CKGetPluginManager());
+#if !defined(VIRTOOLS_21)
+		IterateVariable(expctx, ctx->GetVariableManager());
+#endif
+	}
+
 }

materializer/ExportEnvironment.hpp

@@ -1,6 +0,0 @@
-#pragma once
-#include "stdafx.hpp"
-
-namespace VSW::Materializer::ExportEnvironment {
-
-}

materializer/ExportScript.cpp

@@ -1,5 +1,12 @@
-#include "ExportScript.hpp"
+#include "ExportCore.hpp"
 
 namespace VSW::Materializer::ExportScript {
 
+
+
+
+	void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) {
+
+	}
+
 }

materializer/ExportScript.hpp

@@ -1,6 +0,0 @@
-#pragma once
-#include "stdafx.hpp"
-
-namespace VSW::Materializer::ExportScript {
-
-}

materializer/PluginMain.cpp

@@ -1,4 +1,5 @@
 #include "PluginMain.hpp"
+#include "ExportCore.hpp"
 
 namespace VSW::Materializer::PluginMain {
 	
@@ -62,8 +63,8 @@ namespace VSW::Materializer::PluginMain {
 	static void UpdateMenu() {
 		g_Plugininterface->ClearPluginMenu(g_MainMenu);
 
-		g_Plugininterface->AddPluginMenuItem(g_MainMenu, 0, "Export Scripts");
+		g_Plugininterface->AddPluginMenuItem(g_MainMenu, 0, "Export Script");
-		g_Plugininterface->AddPluginMenuItem(g_MainMenu, 1, "Export Context");
+		g_Plugininterface->AddPluginMenuItem(g_MainMenu, 1, "Export Document");
 		g_Plugininterface->AddPluginMenuItem(g_MainMenu, 2, "Export Environment");
 		g_Plugininterface->AddPluginMenuItem(g_MainMenu, -1, NULL, TRUE);
 		g_Plugininterface->AddPluginMenuItem(g_MainMenu, 3, "Report Bug");

materializer/Utilities.cpp

@@ -2,4 +2,55 @@
 
 namespace VSW::Materializer::Utilities {
 
+	std::string RelativeAddress(const void* absolute_addr) {
+		// prepare return value
+		std::string ret("<error>");
+
+		// If address is nullptr, return directly
+		if (absolute_addr == nullptr) {
+			ret = "<nullptr>";
+			return ret;
+		}
+
+		// Get the module handle which given function address belongs to
+		// Reference: https://stackoverflow.com/questions/557081/how-do-i-get-the-hmodule-for-the-currently-executing-code
+		HMODULE hModule = NULL;
+		GetModuleHandleExW(
+			GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,	// get address and do not inc ref counter.
+			(LPCWSTR)absolute_addr,
+			&hModule);
+		if (hModule == NULL)
+			return ret;
+
+		// Get full path to module
+		YYCC::yycc_u8string u8_module_path;
+		if (!YYCC::WinFctHelper::GetModuleFileName(hModule, u8_module_path))
+			return ret;
+		// Then get its file name part
+		auto module_path = YYCC::FsPathPatch::FromUTF8Path(u8_module_path.c_str());
+		auto u8_module_name = YYCC::FsPathPatch::ToUTF8Path(module_path.filename());
+		
+		// Get the base address of current module
+		// HMODULE is the base address of loaded module
+		// Reference: https://stackoverflow.com/questions/4298331/exe-or-dll-image-base-address
+		uintptr_t relative_addr = reinterpret_cast<uintptr_t>(absolute_addr) - reinterpret_cast<uintptr_t>(hModule);
+		
+		// get final result
+		auto u8_ret = YYCC::StringHelper::Printf(YYCC_U8("%s+%" PRI_XPTR_LEFT_PADDING PRIXPTR), u8_module_name.c_str(), relative_addr);
+		ret = YYCC::EncodingHelper::ToOrdinaryView(u8_ret);
+		return ret;
+	}
+
+	void CopyGuid(int64_t& dst, const CKGUID& src) {
+		// todo: use template argument to implement this to improve performance
+		if (sizeof(dst) != sizeof(src))
+			throw std::invalid_argument("CKGUID size error");
+		std::memcpy(&dst, &src, sizeof(int64_t));
+	}
+
+	void CopyCKString(std::string& storage, const char* str) {
+		if (str == nullptr) storage = "<unamed>";
+		else storage = str;
+	}
+
 }

materializer/Utilities.hpp

@@ -3,4 +3,18 @@
 
 namespace VSW::Materializer::Utilities {
 	
+	/// @brief The value representing a invalid CK_ID.
+	constexpr CK_ID INVALID_CK_ID = static_cast<CK_ID>(-1);
+
+	/**
+	 * @brief Get relative address from given absolute address
+	 * @details This function is used when exporting function pointer into database.
+	 * @param[in] absolute_addr The absolute address
+	 * @return Module based relative address like \c xxx.dll+0x00000000.
+	*/
+	std::string RelativeAddress(const void* absolute_addr);
+
+	void CopyGuid(int64_t& dst, const CKGUID& src);
+	void CopyCKString(std::string& storage, const char* str);
+
 }

shared/CMakeLists.txt

@@ -4,7 +4,7 @@ add_library(VSWShared STATIC "")
 target_sources(VSWShared
 PRIVATE
     # Sources
-    "EnumTypes.cpp"
+    "GenericDataTypes.cpp"
 )
 # Setup header files
 target_sources(VSWShared
@@ -12,7 +12,7 @@ PUBLIC
 FILE_SET HEADERS
 FILES
     # Headers
-    "EnumTypes.hpp"
+    "GenericDataTypes.hpp"
 )
 # Setup include directory
 target_include_directories(VSWShared

shared/GenericDataTypes.hpp

@@ -1,14 +1,14 @@
 #pragma once
 #include <cinttypes>
 
-namespace VSW {
+namespace VSW::DataTypes {
 
-	enum class BehaviorLinkIOType : uint32_t {
+	enum class BehaviorLinkIOType : int {
 		Input,
 		Output
 	};
 
-	enum class ParameterLinkIOType : uint32_t {
+	enum class ParameterLinkIOType : int {
 		ParameterIn,
 		ParameterOut,
 		/// @brief When using this, ignore [index] and [input_is_bb], set [input_index] to -1