From 4ee11c29c9511c78ff7ed2b90653578601ee5daf Mon Sep 17 00:00:00 2001 From: yyc12345 Date: Fri, 2 Aug 2024 17:04:37 +0800 Subject: [PATCH] refactor: migrate old code --- materializer/CMakeLists.txt | 8 +- materializer/DataTypes.hpp | 110 ++++++-- materializer/Database.cpp | 263 +++++++++++++++++- materializer/Database.hpp | 43 ++- materializer/ExportContext.cpp | 5 - materializer/ExportContext.hpp | 6 - materializer/ExportCore.hpp | 18 ++ materializer/ExportDocument.cpp | 12 + materializer/ExportEnvironment.cpp | 169 ++++++++++- materializer/ExportEnvironment.hpp | 6 - materializer/ExportScript.cpp | 9 +- materializer/ExportScript.hpp | 6 - materializer/PluginMain.cpp | 5 +- materializer/Utilities.cpp | 51 ++++ materializer/Utilities.hpp | 14 + shared/CMakeLists.txt | 4 +- .../{EnumTypes.cpp => GenericDataTypes.cpp} | 0 .../{EnumTypes.hpp => GenericDataTypes.hpp} | 6 +- 18 files changed, 655 insertions(+), 80 deletions(-) delete mode 100644 materializer/ExportContext.cpp delete mode 100644 materializer/ExportContext.hpp create mode 100644 materializer/ExportCore.hpp create mode 100644 materializer/ExportDocument.cpp delete mode 100644 materializer/ExportEnvironment.hpp delete mode 100644 materializer/ExportScript.hpp rename shared/{EnumTypes.cpp => GenericDataTypes.cpp} (100%) rename shared/{EnumTypes.hpp => GenericDataTypes.hpp} (80%) diff --git a/materializer/CMakeLists.txt b/materializer/CMakeLists.txt index 6da98c2..513182b 100644 --- a/materializer/CMakeLists.txt +++ b/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 - ExportEnvironment.hpp - ExportScript.hpp + ExportCore.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 diff --git a/materializer/DataTypes.hpp b/materializer/DataTypes.hpp index 7782e29..f14f9bd 100644 --- a/materializer/DataTypes.hpp +++ b/materializer/DataTypes.hpp @@ -1,10 +1,11 @@ #pragma once #include "stdafx.hpp" +#include "GenericDataTypes.hpp" namespace VSW::Materializer::DataTypes { namespace Script { - + struct Table_script { CK_ID thisobj; std::string host_name; @@ -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 in1_guid; - std::string in2_guid; - std::string out_guid; - std::string op_guid; + std::string func_ptr; + int64_t in1_guid; + int64_t in2_guid; + int64_t out_guid; + int64_t op_guid; std::string op_name; CKOperationType op_code; }; struct Table_param { CKParameterType index; - std::string guid; - std::string derived_from; + int64_t guid; + int64_t derived_from; std::string type_name; int default_size; - CK_PARAMETERCREATEDEFAULTFUNCTION func_CreateDefault; - CK_PARAMETERDELETEFUNCTION func_Delete; - CK_PARAMETERSAVELOADFUNCTION func_SaveLoad; - CK_PARAMETERCHECKFUNCTION func_Check; - CK_PARAMETERCOPYFUNCTION func_Copy; - CK_PARAMETERSTRINGFUNCTION func_String; - CK_PARAMETERUICREATORFUNCTION func_UICreator; + std::string func_CreateDefault; + std::string func_Delete; + std::string func_SaveLoad; + std::string func_Check; + std::string func_Copy; + std::string func_String; + 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; - CK_EXITINSTANCEFCT func_exit; + std::string func_init; + 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; + }; + } } diff --git a/materializer/Database.cpp b/materializer/Database.cpp index 7808b5c..d06d6e6 100644 --- a/materializer/Database.cpp +++ b/materializer/Database.cpp @@ -1,5 +1,6 @@ #include "Database.hpp" #include +#include 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>(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 } diff --git a/materializer/Database.hpp b/materializer/Database.hpp index 1c53e64..1335ceb 100644 --- a/materializer/Database.hpp +++ b/materializer/Database.hpp @@ -1,5 +1,6 @@ #pragma once #include "stdafx.hpp" +#include "DataTypes.hpp" #include #include @@ -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); - virtual ~ContextDatabase(); - ContextDatabase(const ContextDatabase&) = delete; - ContextDatabase& operator=(const ContextDatabase&) = delete; - ContextDatabase(ContextDatabase&&) = delete; - ContextDatabase& operator=(ContextDatabase&&) = delete; - + DocumentDatabase(const YYCC::yycc_u8string_view& file); + virtual ~DocumentDatabase(); + DocumentDatabase(const DocumentDatabase&) = delete; + DocumentDatabase& operator=(const DocumentDatabase&) = delete; + DocumentDatabase(DocumentDatabase&&) = 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 { @@ -83,13 +98,17 @@ namespace VSW::Materializer::Database { EnvironmentDatabase& operator=(const EnvironmentDatabase&) = delete; EnvironmentDatabase(EnvironmentDatabase&&) = delete; EnvironmentDatabase& operator=(EnvironmentDatabase&&) = delete; - + protected: virtual bool PostOpen() override; 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); }; } diff --git a/materializer/ExportContext.cpp b/materializer/ExportContext.cpp deleted file mode 100644 index 5445bff..0000000 --- a/materializer/ExportContext.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include "ExportContext.hpp" - -namespace VSW::Materializer::ExportContext { - -} diff --git a/materializer/ExportContext.hpp b/materializer/ExportContext.hpp deleted file mode 100644 index c87046e..0000000 --- a/materializer/ExportContext.hpp +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once -#include "stdafx.hpp" - -namespace VSW::Materializer::ExportContext { - -} diff --git a/materializer/ExportCore.hpp b/materializer/ExportCore.hpp new file mode 100644 index 0000000..20a601f --- /dev/null +++ b/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); + } + +} diff --git a/materializer/ExportDocument.cpp b/materializer/ExportDocument.cpp new file mode 100644 index 0000000..25718f4 --- /dev/null +++ b/materializer/ExportDocument.cpp @@ -0,0 +1,12 @@ +#include "ExportCore.hpp" + +namespace VSW::Materializer::ExportDocument { + + + + + void Export(CKContext* ctx, YYCC::yycc_u8string_view& db_path) { + + } + +} diff --git a/materializer/ExportEnvironment.cpp b/materializer/ExportEnvironment.cpp index dfbf008..325a03f 100644 --- a/materializer/ExportEnvironment.cpp +++ b/materializer/ExportEnvironment.cpp @@ -1,5 +1,172 @@ -#include "ExportEnvironment.hpp" +#include "ExportCore.hpp" +#include "Database.hpp" +#include "DataTypes.hpp" +#include "Utilities.hpp" +#include 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 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(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 + } + } diff --git a/materializer/ExportEnvironment.hpp b/materializer/ExportEnvironment.hpp deleted file mode 100644 index bda2453..0000000 --- a/materializer/ExportEnvironment.hpp +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once -#include "stdafx.hpp" - -namespace VSW::Materializer::ExportEnvironment { - -} diff --git a/materializer/ExportScript.cpp b/materializer/ExportScript.cpp index 4b5cfc4..1379d23 100644 --- a/materializer/ExportScript.cpp +++ b/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) { + + } + } diff --git a/materializer/ExportScript.hpp b/materializer/ExportScript.hpp deleted file mode 100644 index 230286e..0000000 --- a/materializer/ExportScript.hpp +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once -#include "stdafx.hpp" - -namespace VSW::Materializer::ExportScript { - -} diff --git a/materializer/PluginMain.cpp b/materializer/PluginMain.cpp index 3bce3be..b0c2ebc 100644 --- a/materializer/PluginMain.cpp +++ b/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, 1, "Export Context"); + g_Plugininterface->AddPluginMenuItem(g_MainMenu, 0, "Export Script"); + 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"); diff --git a/materializer/Utilities.cpp b/materializer/Utilities.cpp index c802447..5d6b98f 100644 --- a/materializer/Utilities.cpp +++ b/materializer/Utilities.cpp @@ -2,4 +2,55 @@ namespace VSW::Materializer::Utilities { + std::string RelativeAddress(const void* absolute_addr) { + // prepare return value + std::string ret(""); + + // If address is nullptr, return directly + if (absolute_addr == nullptr) { + ret = ""; + 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(absolute_addr) - reinterpret_cast(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 = ""; + else storage = str; + } + } diff --git a/materializer/Utilities.hpp b/materializer/Utilities.hpp index 7be1ee0..eed7b89 100644 --- a/materializer/Utilities.hpp +++ b/materializer/Utilities.hpp @@ -2,5 +2,19 @@ #include "stdafx.hpp" namespace VSW::Materializer::Utilities { + + /// @brief The value representing a invalid CK_ID. + constexpr CK_ID INVALID_CK_ID = static_cast(-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); } diff --git a/shared/CMakeLists.txt b/shared/CMakeLists.txt index dc46bbd..cfab01e 100644 --- a/shared/CMakeLists.txt +++ b/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 diff --git a/shared/EnumTypes.cpp b/shared/GenericDataTypes.cpp similarity index 100% rename from shared/EnumTypes.cpp rename to shared/GenericDataTypes.cpp diff --git a/shared/EnumTypes.hpp b/shared/GenericDataTypes.hpp similarity index 80% rename from shared/EnumTypes.hpp rename to shared/GenericDataTypes.hpp index 4ead893..c9603c1 100644 --- a/shared/EnumTypes.hpp +++ b/shared/GenericDataTypes.hpp @@ -1,14 +1,14 @@ #pragma once #include -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