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 \
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

1
launcher/translation/chinese.ts
View File

@@ -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"/>

392
lobby/SQLiteConnection.cpp
View File

@@ -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);
}

230
lobby/SQLiteConnection.h
View File

@@ -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;
};