games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-08-13 19:54:17 +02:00
Code Issues Releases Activity

Fix build

Browse Source
This commit is contained in:
Ivan Savenko
2024-01-12 18:07:58 +02:00
parent 033b2889c4
commit 93d78edfb9
4 changed files with 312 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CI/linux-qt6/before_install.sh
View File

@@ -7,4 +7,4 @@ sudo apt-get install libboost-all-dev \
libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-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 \ 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 \ 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

1
launcher/translation/chinese.ts
View File

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

392
lobby/SQLiteConnection.cpp
View File

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

230
lobby/SQLiteConnection.h
View File

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