{

class Locker

{

public:

Locker(SQLiteDatabase & db) noexcept;

Locker(sqlite3_stmt * stmt) noexcept;

inline Locker(sqlite3_mutex * mutex) noexcept : m_Mutex(mutex), m_Locked(false) { relock(); }

inline ~Locker() noexcept { unlock(); }

void unlock() noexcept;

void relock() noexcept;

private:

sqlite3_mutex * m_Mutex;

bool m_Locked;

Locker(const Locker &) = delete;

Locker & operator=(const Locker &) = delete;

};

SQLiteDatabase(const char * file);

SQLiteDatabase(const std::string & file);

~SQLiteDatabase();

inline const std::string & fileName() const { return m_File; }

inline sqlite3 * handle() const { return m_Handle; }

void transaction(const std::function<void()> & protectedCode);

int64_t lastInsertId() const;

void exec(const char * sql);

void exec(const std::string & sql);

void exec(const char * sql, const std::function<void(const SQLiteCursor & cursor)> & onRow);

void exec(const std::string & sql, const std::function<void(const SQLiteCursor & cursor)> & onRow);

void exec(const char * sql, const std::function<void(const SQLiteCursor & cursor)> & onRow, size_t limit);

void exec(const std::string & sql, const std::function<void(const SQLiteCursor & cursor)> & onRow, size_t limit);

std::string m_File;

sqlite3 * m_Handle;

sqlite3_stmt * m_StmtBegin;

sqlite3_stmt * m_StmtRollback;

sqlite3_stmt * m_StmtCommit;

int m_InTransaction;

bool m_TransactionFailed;

void begin(Locker & locker);

void rollback(Locker & locker);

void commit(Locker & locker);

void prepare(Locker & locker, sqlite3_stmt *& stmt, const char * sql);

static void exec(Locker & locker, sqlite3_stmt * stmt);

static void exec(Locker & locker, sqlite3_stmt * stmt, const std::function<void()> & onRow);

static void exec(Locker & locker, sqlite3_stmt * stmt, const std::function<void()> & onRow, size_t limit);

SQLiteDatabase(const SQLiteDatabase &) = delete;

SQLiteDatabase & operator=(const SQLiteDatabase &) = delete;

friend class SQLiteCursor;

friend class SQLiteStatement;

friend class SQLiteDatabase::Locker;