Fix build

CI/linux-qt6/before_install.sh

@@ -7,4 +7,4 @@ sudo apt-get install libboost-all-dev \
 libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev \
 qt6-base-dev qt6-base-dev-tools qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools \
 ninja-build zlib1g-dev libavformat-dev libswscale-dev libtbb-dev libluajit-5.1-dev \
-libminizip-dev libfuzzylite-dev # Optional dependencies
+libminizip-dev libfuzzylite-dev libsqlite3-dev # Optional dependencies

launcher/translation/chinese.ts

@@ -1027,7 +1027,6 @@ Heroes® of Might and Magic® III HD is currently not supported!</source>
     </message>
 </context>
 <context>
-        <translation>模组不匹配</translation>
     <name>MainWindow</name>
     <message>
         <location filename="../mainwindow_moc.ui" line="20"/>

lobby/SQLiteConnection.cpp

@@ -1,196 +1,196 @@
-/*
- * SQLiteConnection.cpp, part of VCMI engine
- *
- * Authors: listed in file AUTHORS in main folder
- *
- * License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
- *
- */
-#include "StdInc.h"
-#include "SQLiteConnection.h"
-
-#include <sqlite3.h>
-
-[[noreturn]] static void handleSQLiteError(sqlite3 * connection)
-{
-	const char * message = sqlite3_errmsg(connection);
-	throw std::runtime_error(std::string("SQLite error: ") + message);
-}
-
-static void checkSQLiteError(sqlite3 * connection, int result)
-{
-	if(result != SQLITE_OK)
-		handleSQLiteError(connection);
-}
-
-SQLiteStatement::SQLiteStatement(SQLiteInstance & instance, sqlite3_stmt * statement)
-	: m_instance(instance)
-	, m_statement(statement)
-{
-}
-
-SQLiteStatement::~SQLiteStatement()
-{
-	int result = sqlite3_finalize(m_statement);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-bool SQLiteStatement::execute()
-{
-	int result = sqlite3_step(m_statement);
-
-	switch(result)
-	{
-		case SQLITE_DONE:
-			return false;
-		case SQLITE_ROW:
-			return true;
-		default:
-			checkSQLiteError(m_instance.m_connection, result);
-			return false;
-	}
-}
-
-void SQLiteStatement::reset()
-{
-	int result = sqlite3_reset(m_statement);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::clear()
-{
-	int result = sqlite3_clear_bindings(m_statement);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const double & value)
-{
-	int result = sqlite3_bind_double(m_statement, static_cast<int>(index), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const bool & value)
-{
-	int result = sqlite3_bind_int(m_statement, static_cast<int>(value), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const uint8_t & value)
-{
-	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const uint16_t & value)
-{
-	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-void SQLiteStatement::setBindSingle(size_t index, const uint32_t & value)
-{
-	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const int32_t & value)
-{
-	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const int64_t & value)
-{
-	int result = sqlite3_bind_int64(m_statement, static_cast<int>(index), value);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const std::string & value)
-{
-	int result = sqlite3_bind_text(m_statement, static_cast<int>(index), value.data(), static_cast<int>(value.size()), SQLITE_STATIC);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::setBindSingle(size_t index, const char * value)
-{
-	int result = sqlite3_bind_text(m_statement, static_cast<int>(index), value, -1, SQLITE_STATIC);
-	checkSQLiteError(m_instance.m_connection, result);
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, double & value)
-{
-	value = sqlite3_column_double(m_statement, static_cast<int>(index));
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, bool & value)
-{
-	value = sqlite3_column_int(m_statement, static_cast<int>(index)) != 0;
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, uint8_t & value)
-{
-	value = static_cast<uint8_t>(sqlite3_column_int(m_statement, static_cast<int>(index)));
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, uint16_t & value)
-{
-	value = static_cast<uint16_t>(sqlite3_column_int(m_statement, static_cast<int>(index)));
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, int32_t & value)
-{
-	value = sqlite3_column_int(m_statement, static_cast<int>(index));
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, uint32_t & value)
-{
-	value = sqlite3_column_int(m_statement, static_cast<int>(index));
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, int64_t & value)
-{
-	value = sqlite3_column_int64(m_statement, static_cast<int>(index));
-}
-
-void SQLiteStatement::getColumnSingle(size_t index, std::string & value)
-{
-	const auto * value_raw = sqlite3_column_text(m_statement, static_cast<int>(index));
-	value = reinterpret_cast<const char *>(value_raw);
-}
-
-SQLiteInstancePtr SQLiteInstance::open(const boost::filesystem::path & db_path, bool allow_write)
-{
-	int flags = allow_write ? (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE) : SQLITE_OPEN_READONLY;
-
-	sqlite3 * connection;
-	int result = sqlite3_open_v2(db_path.c_str(), &connection, flags, nullptr);
-
-	if(result == SQLITE_OK)
-		return SQLiteInstancePtr(new SQLiteInstance(connection));
-
-	sqlite3_close(connection);
-	handleSQLiteError(connection);
-}
-
-SQLiteInstance::SQLiteInstance(sqlite3 * connection)
-	: m_connection(connection)
-{
-}
-
-SQLiteInstance::~SQLiteInstance()
-{
-	int result = sqlite3_close(m_connection);
-	checkSQLiteError(m_connection, result);
-}
-
-SQLiteStatementPtr SQLiteInstance::prepare(const std::string & sql_text)
-{
-	sqlite3_stmt * statement;
-	int result = sqlite3_prepare_v2(m_connection, sql_text.data(), static_cast<int>(sql_text.size()), &statement, nullptr);
-
-	if(result == SQLITE_OK)
-		return SQLiteStatementPtr(new SQLiteStatement(*this, statement));
-
-	sqlite3_finalize(statement);
-	handleSQLiteError(m_connection);
-}
+/*
+ * SQLiteConnection.cpp, part of VCMI engine
+ *
+ * Authors: listed in file AUTHORS in main folder
+ *
+ * License: GNU General Public License v2.0 or later
+ * Full text of license available in license.txt file, in main folder
+ *
+ */
+#include "StdInc.h"
+#include "SQLiteConnection.h"
+
+#include <sqlite3.h>
+
+[[noreturn]] static void handleSQLiteError(sqlite3 * connection)
+{
+	const char * message = sqlite3_errmsg(connection);
+	throw std::runtime_error(std::string("SQLite error: ") + message);
+}
+
+static void checkSQLiteError(sqlite3 * connection, int result)
+{
+	if(result != SQLITE_OK)
+		handleSQLiteError(connection);
+}
+
+SQLiteStatement::SQLiteStatement(SQLiteInstance & instance, sqlite3_stmt * statement)
+	: m_instance(instance)
+	, m_statement(statement)
+{
+}
+
+SQLiteStatement::~SQLiteStatement()
+{
+	int result = sqlite3_finalize(m_statement);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+bool SQLiteStatement::execute()
+{
+	int result = sqlite3_step(m_statement);
+
+	switch(result)
+	{
+		case SQLITE_DONE:
+			return false;
+		case SQLITE_ROW:
+			return true;
+		default:
+			checkSQLiteError(m_instance.m_connection, result);
+			return false;
+	}
+}
+
+void SQLiteStatement::reset()
+{
+	int result = sqlite3_reset(m_statement);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::clear()
+{
+	int result = sqlite3_clear_bindings(m_statement);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const double & value)
+{
+	int result = sqlite3_bind_double(m_statement, static_cast<int>(index), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const bool & value)
+{
+	int result = sqlite3_bind_int(m_statement, static_cast<int>(value), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const uint8_t & value)
+{
+	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const uint16_t & value)
+{
+	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+void SQLiteStatement::setBindSingle(size_t index, const uint32_t & value)
+{
+	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const int32_t & value)
+{
+	int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const int64_t & value)
+{
+	int result = sqlite3_bind_int64(m_statement, static_cast<int>(index), value);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const std::string & value)
+{
+	int result = sqlite3_bind_text(m_statement, static_cast<int>(index), value.data(), static_cast<int>(value.size()), SQLITE_STATIC);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::setBindSingle(size_t index, const char * value)
+{
+	int result = sqlite3_bind_text(m_statement, static_cast<int>(index), value, -1, SQLITE_STATIC);
+	checkSQLiteError(m_instance.m_connection, result);
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, double & value)
+{
+	value = sqlite3_column_double(m_statement, static_cast<int>(index));
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, bool & value)
+{
+	value = sqlite3_column_int(m_statement, static_cast<int>(index)) != 0;
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, uint8_t & value)
+{
+	value = static_cast<uint8_t>(sqlite3_column_int(m_statement, static_cast<int>(index)));
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, uint16_t & value)
+{
+	value = static_cast<uint16_t>(sqlite3_column_int(m_statement, static_cast<int>(index)));
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, int32_t & value)
+{
+	value = sqlite3_column_int(m_statement, static_cast<int>(index));
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, uint32_t & value)
+{
+	value = sqlite3_column_int(m_statement, static_cast<int>(index));
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, int64_t & value)
+{
+	value = sqlite3_column_int64(m_statement, static_cast<int>(index));
+}
+
+void SQLiteStatement::getColumnSingle(size_t index, std::string & value)
+{
+	const auto * value_raw = sqlite3_column_text(m_statement, static_cast<int>(index));
+	value = reinterpret_cast<const char *>(value_raw);
+}
+
+SQLiteInstancePtr SQLiteInstance::open(const boost::filesystem::path & db_path, bool allow_write)
+{
+	int flags = allow_write ? (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE) : SQLITE_OPEN_READONLY;
+
+	sqlite3 * connection;
+	int result = sqlite3_open_v2(db_path.c_str(), &connection, flags, nullptr);
+
+	if(result == SQLITE_OK)
+		return SQLiteInstancePtr(new SQLiteInstance(connection));
+
+	sqlite3_close(connection);
+	handleSQLiteError(connection);
+}
+
+SQLiteInstance::SQLiteInstance(sqlite3 * connection)
+	: m_connection(connection)
+{
+}
+
+SQLiteInstance::~SQLiteInstance()
+{
+	int result = sqlite3_close(m_connection);
+	checkSQLiteError(m_connection, result);
+}
+
+SQLiteStatementPtr SQLiteInstance::prepare(const std::string & sql_text)
+{
+	sqlite3_stmt * statement;
+	int result = sqlite3_prepare_v2(m_connection, sql_text.data(), static_cast<int>(sql_text.size()), &statement, nullptr);
+
+	if(result == SQLITE_OK)
+		return SQLiteStatementPtr(new SQLiteStatement(*this, statement));
+
+	sqlite3_finalize(statement);
+	handleSQLiteError(m_connection);
+}

lobby/SQLiteConnection.h

@@ -1,115 +1,115 @@
-/*
- * SQLiteConnection.h, part of VCMI engine
- *
- * Authors: listed in file AUTHORS in main folder
- *
- * License: GNU General Public License v2.0 or later
- * Full text of license available in license.txt file, in main folder
- *
- */
-#pragma once
-
-typedef struct sqlite3 sqlite3;
-typedef struct sqlite3_stmt sqlite3_stmt;
-
-class SQLiteInstance;
-class SQLiteStatement;
-
-using SQLiteInstancePtr = std::unique_ptr<SQLiteInstance>;
-using SQLiteStatementPtr = std::unique_ptr<SQLiteStatement>;
-
-class SQLiteStatement : boost::noncopyable
-{
-public:
-	friend class SQLiteInstance;
-
-	bool execute();
-	void reset();
-	void clear();
-
-	~SQLiteStatement();
-
-	template<typename... Args>
-	void executeOnce(const Args &... args)
-	{
-		setBinds(args...);
-		execute();
-		reset();
-	}
-
-	template<typename... Args>
-	void setBinds(const Args &... args)
-	{
-		setBindSingle(1, args...); // The leftmost SQL parameter has an index of 1
-	}
-
-	template<typename... Args>
-	void getColumns(Args &... args)
-	{
-		getColumnSingle(0, args...); // The leftmost column of the result set has the index 0
-	}
-
-private:
-	void setBindSingle(size_t index, const double & value);
-	void setBindSingle(size_t index, const bool & value);
-	void setBindSingle(size_t index, const uint8_t & value);
-	void setBindSingle(size_t index, const uint16_t & value);
-	void setBindSingle(size_t index, const uint32_t & value);
-	void setBindSingle(size_t index, const int32_t & value);
-	void setBindSingle(size_t index, const int64_t & value);
-	void setBindSingle(size_t index, const std::string & value);
-	void setBindSingle(size_t index, const char * value);
-
-	void getColumnSingle(size_t index, double & value);
-	void getColumnSingle(size_t index, bool & value);
-	void getColumnSingle(size_t index, uint8_t & value);
-	void getColumnSingle(size_t index, uint16_t & value);
-	void getColumnSingle(size_t index, uint32_t & value);
-	void getColumnSingle(size_t index, int32_t & value);
-	void getColumnSingle(size_t index, int64_t & value);
-	void getColumnSingle(size_t index, std::string & value);
-
-	template<typename Rep, typename Period>
-	void getColumnSingle(size_t index, std::chrono::duration<Rep, Period> & value)
-	{
-		int64_t durationValue = 0;
-		getColumnSingle(index, durationValue);
-		value = std::chrono::duration<Rep, Period>(durationValue);
-	}
-
-	SQLiteStatement(SQLiteInstance & instance, sqlite3_stmt * statement);
-
-	template<typename T, typename... Args>
-	void setBindSingle(size_t index, T const & arg, const Args &... args)
-	{
-		setBindSingle(index, arg);
-		setBindSingle(index + 1, args...);
-	}
-
-	template<typename T, typename... Args>
-	void getColumnSingle(size_t index, T & arg, Args &... args)
-	{
-		getColumnSingle(index, arg);
-		getColumnSingle(index + 1, args...);
-	}
-
-	SQLiteInstance & m_instance;
-	sqlite3_stmt * m_statement;
-};
-
-class SQLiteInstance : boost::noncopyable
-{
-public:
-	friend class SQLiteStatement;
-
-	static SQLiteInstancePtr open(const boost::filesystem::path & db_path, bool allow_write);
-
-	~SQLiteInstance();
-
-	SQLiteStatementPtr prepare(const std::string & statement);
-
-private:
-	SQLiteInstance(sqlite3 * connection);
-
-	sqlite3 * m_connection;
-};
+/*
+ * SQLiteConnection.h, part of VCMI engine
+ *
+ * Authors: listed in file AUTHORS in main folder
+ *
+ * License: GNU General Public License v2.0 or later
+ * Full text of license available in license.txt file, in main folder
+ *
+ */
+#pragma once
+
+typedef struct sqlite3 sqlite3;
+typedef struct sqlite3_stmt sqlite3_stmt;
+
+class SQLiteInstance;
+class SQLiteStatement;
+
+using SQLiteInstancePtr = std::unique_ptr<SQLiteInstance>;
+using SQLiteStatementPtr = std::unique_ptr<SQLiteStatement>;
+
+class SQLiteStatement : boost::noncopyable
+{
+public:
+	friend class SQLiteInstance;
+
+	bool execute();
+	void reset();
+	void clear();
+
+	~SQLiteStatement();
+
+	template<typename... Args>
+	void executeOnce(const Args &... args)
+	{
+		setBinds(args...);
+		execute();
+		reset();
+	}
+
+	template<typename... Args>
+	void setBinds(const Args &... args)
+	{
+		setBindSingle(1, args...); // The leftmost SQL parameter has an index of 1
+	}
+
+	template<typename... Args>
+	void getColumns(Args &... args)
+	{
+		getColumnSingle(0, args...); // The leftmost column of the result set has the index 0
+	}
+
+private:
+	void setBindSingle(size_t index, const double & value);
+	void setBindSingle(size_t index, const bool & value);
+	void setBindSingle(size_t index, const uint8_t & value);
+	void setBindSingle(size_t index, const uint16_t & value);
+	void setBindSingle(size_t index, const uint32_t & value);
+	void setBindSingle(size_t index, const int32_t & value);
+	void setBindSingle(size_t index, const int64_t & value);
+	void setBindSingle(size_t index, const std::string & value);
+	void setBindSingle(size_t index, const char * value);
+
+	void getColumnSingle(size_t index, double & value);
+	void getColumnSingle(size_t index, bool & value);
+	void getColumnSingle(size_t index, uint8_t & value);
+	void getColumnSingle(size_t index, uint16_t & value);
+	void getColumnSingle(size_t index, uint32_t & value);
+	void getColumnSingle(size_t index, int32_t & value);
+	void getColumnSingle(size_t index, int64_t & value);
+	void getColumnSingle(size_t index, std::string & value);
+
+	template<typename Rep, typename Period>
+	void getColumnSingle(size_t index, std::chrono::duration<Rep, Period> & value)
+	{
+		int64_t durationValue = 0;
+		getColumnSingle(index, durationValue);
+		value = std::chrono::duration<Rep, Period>(durationValue);
+	}
+
+	SQLiteStatement(SQLiteInstance & instance, sqlite3_stmt * statement);
+
+	template<typename T, typename... Args>
+	void setBindSingle(size_t index, T const & arg, const Args &... args)
+	{
+		setBindSingle(index, arg);
+		setBindSingle(index + 1, args...);
+	}
+
+	template<typename T, typename... Args>
+	void getColumnSingle(size_t index, T & arg, Args &... args)
+	{
+		getColumnSingle(index, arg);
+		getColumnSingle(index + 1, args...);
+	}
+
+	SQLiteInstance & m_instance;
+	sqlite3_stmt * m_statement;
+};
+
+class SQLiteInstance : boost::noncopyable
+{
+public:
+	friend class SQLiteStatement;
+
+	static SQLiteInstancePtr open(const boost::filesystem::path & db_path, bool allow_write);
+
+	~SQLiteInstance();
+
+	SQLiteStatementPtr prepare(const std::string & statement);
+
+private:
+	SQLiteInstance(sqlite3 * connection);
+
+	sqlite3 * m_connection;
+};