games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-11-29 23:07:48 +02:00
Code Issues Releases Activity

Fix code style consistency in lobby server project

Browse Source
This commit is contained in:
Ivan Savenko
2023-12-29 13:19:04 +02:00
parent 428a71087a
commit 50c1452221
6 changed files with 134 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
lobby/SQLiteConnection.cpp
View File

@@ -12,111 +12,113 @@
#include <sqlite3.h>
static void on_sqlite_error( sqlite3 * connection, [[maybe_unused]] int result )
[[noreturn]] static void handleSQLiteError(sqlite3 * connection)
{
if ( result != SQLITE_OK )
{
const char * message = sqlite3_errmsg( connection );
printf( "sqlite error: %s\n", message );
}
assert( result == SQLITE_OK );
const char * message = sqlite3_errmsg(connection);
throw std::runtime_error(std::string("SQLite error: ") + message);
}
SQLiteStatement::SQLiteStatement( SQLiteInstance & instance, sqlite3_stmt * statement ):
m_instance( instance ),
m_statement( statement )
{ }
SQLiteStatement::~SQLiteStatement( )
{
int result = sqlite3_finalize( m_statement );
on_sqlite_error( m_instance.m_connection, result );
static void checkSQLiteError(sqlite3 * connection, int result)
{
if(result != SQLITE_OK)
handleSQLiteError(connection);
}
bool SQLiteStatement::execute( )
{
int result = sqlite3_step( m_statement );
SQLiteStatement::SQLiteStatement(SQLiteInstance & instance, sqlite3_stmt * statement)
: m_instance(instance)
, m_statement(statement)
{
}
switch ( result )
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:
on_sqlite_error( m_instance.m_connection, result );
checkSQLiteError(m_instance.m_connection, result);
return false;
}
}
void SQLiteStatement::reset( )
void SQLiteStatement::reset()
{
int result = sqlite3_reset( m_statement );
on_sqlite_error( m_instance.m_connection, result );
int result = sqlite3_reset(m_statement);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::clear()
{
int result = sqlite3_clear_bindings(m_statement);
on_sqlite_error(m_instance.m_connection, result);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle( size_t index, double const & value )
void SQLiteStatement::setBindSingle(size_t index, const double & value)
{
int result = sqlite3_bind_double( m_statement, static_cast<int>(index), value );
on_sqlite_error( m_instance.m_connection, result );
int result = sqlite3_bind_double(m_statement, static_cast<int>(index), value);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle(size_t index, uint8_t const & value)
void SQLiteStatement::setBindSingle(size_t index, const uint8_t & value)
{
int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
on_sqlite_error(m_instance.m_connection, result);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle(size_t index, uint16_t const & value)
void SQLiteStatement::setBindSingle(size_t index, const uint16_t & value)
{
int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
on_sqlite_error(m_instance.m_connection, result);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle(size_t index, uint32_t const & value)
void SQLiteStatement::setBindSingle(size_t index, const uint32_t & value)
{
int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
on_sqlite_error(m_instance.m_connection, result);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle( size_t index, int32_t const & value )
void SQLiteStatement::setBindSingle(size_t index, const int32_t & value)
{
int result = sqlite3_bind_int( m_statement, static_cast<int>( index ), value );
on_sqlite_error( m_instance.m_connection, result );
int result = sqlite3_bind_int(m_statement, static_cast<int>(index), value);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle( size_t index, int64_t const & value )
void SQLiteStatement::setBindSingle(size_t index, const int64_t & value)
{
int result = sqlite3_bind_int64( m_statement, static_cast<int>( index ), value );
on_sqlite_error( m_instance.m_connection, result );
int result = sqlite3_bind_int64(m_statement, static_cast<int>(index), value);
checkSQLiteError(m_instance.m_connection, result);
}
void SQLiteStatement::setBindSingle( size_t index, std::string const & 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 );
on_sqlite_error( m_instance.m_connection, result );
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, char const * 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 );
on_sqlite_error( m_instance.m_connection, result );
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 )
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, 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)
@@ -124,9 +126,9 @@ 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 )
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)
@@ -134,65 +136,50 @@ 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 )
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)
{
auto value_raw = sqlite3_column_text(m_statement, static_cast<int>(index));
value = reinterpret_cast<char const*>( value_raw );
const auto * value_raw = sqlite3_column_text(m_statement, static_cast<int>(index));
value = reinterpret_cast<const char *>(value_raw);
}
void SQLiteStatement::getColumnBlob(size_t index, std::byte * value, [[maybe_unused]] size_t capacity)
{
auto * blob_data = sqlite3_column_blob(m_statement, static_cast<int>(index));
size_t blob_size = sqlite3_column_bytes(m_statement, static_cast<int>(index));
assert(blob_size < capacity);
std::copy_n(static_cast<std::byte const*>(blob_data), blob_size, value);
value[blob_size] = std::byte(0);
}
SQLiteInstancePtr SQLiteInstance::open( std::string const & db_path, bool allow_write)
SQLiteInstancePtr SQLiteInstance::open(const std::string & 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 );
int result = sqlite3_open_v2(db_path.c_str(), &connection, flags, nullptr);
on_sqlite_error( connection, result );
if(result == SQLITE_OK)
return SQLiteInstancePtr(new SQLiteInstance(connection));
assert(result == SQLITE_OK);
if ( result == SQLITE_OK )
return SQLiteInstancePtr( new SQLiteInstance( connection ) );
sqlite3_close( connection );
return SQLiteInstancePtr( );
sqlite3_close(connection);
handleSQLiteError(connection);
}
SQLiteInstance::SQLiteInstance( sqlite3 * connection ):
m_connection( connection )
{ }
SQLiteInstance::~SQLiteInstance( )
SQLiteInstance::SQLiteInstance(sqlite3 * connection)
: m_connection(connection)
{
int result = sqlite3_close( m_connection );
on_sqlite_error( m_connection, result );
}
SQLiteStatementPtr SQLiteInstance::prepare( std::string const & sql_text )
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 );
on_sqlite_error( m_connection, result );
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 );
return SQLiteStatementPtr( );
if(result == SQLITE_OK)
return SQLiteStatementPtr(new SQLiteStatement(*this, statement));
sqlite3_finalize(statement);
handleSQLiteError(m_connection);
}