Initial commit.

src/database/CMakeLists.txt

@@ -0,0 +1,13 @@
+list(APPEND database_LIB_INCLUDES 
+    Database.cpp
+    DatabaseManager.cpp
+    database_interfaces/SqliteInterface.cpp)
+
+add_library(database SHARED ${database_LIB_INCLUDES})
+
+target_include_directories(database PUBLIC
+                          "${CMAKE_CURRENT_SOURCE_DIR}"
+                          "${CMAKE_CURRENT_SOURCE_DIR}/database_interfaces"
+                          )
+                          
+target_link_libraries(database PUBLIC sqlite3)

src/database/Database.cpp

@@ -0,0 +1,27 @@
+#include "Database.h"
+
+Database::Database()
+	: mPath()
+{
+
+}
+
+Database::~Database()
+{
+
+}
+
+std::shared_ptr<Database> Database::Create()
+{
+	return std::make_shared<Database>();
+}
+
+void Database::SetPath(const std::string& path)
+{
+	mPath = path;
+}
+
+std::string Database::GetPath()
+{
+	return mPath;
+}

src/database/Database.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+class Database
+{
+
+	std::string mPath;
+
+public:
+
+	Database();
+
+	~Database();
+
+	static std::shared_ptr<Database> Create();
+
+	void SetPath(const std::string& path);
+
+	std::string GetPath();
+};
+
+using DatabasePtr = std::shared_ptr<Database>;

src/database/DatabaseManager.cpp

@@ -0,0 +1,36 @@
+#include "DatabaseManager.h"
+
+DatabaseManager::DatabaseManager()
+	: mDatabase(),
+	  mDatabaseInterface()
+{
+
+}
+
+DatabaseManager::~DatabaseManager()
+{
+
+}
+
+std::shared_ptr<DatabaseManager> DatabaseManager::Create()
+{
+	return std::make_shared<DatabaseManager>();
+}
+
+
+void DatabaseManager::CreateDatabase(const std::string& path)
+{
+	mDatabase = Database::Create();
+	mDatabase->SetPath(path);
+
+	mDatabaseInterface = SqliteInterface::Create();
+	mDatabaseInterface->Open(mDatabase);
+}
+
+void DatabaseManager::OnShutDown()
+{
+	if(mDatabaseInterface)
+	{
+		mDatabaseInterface->Close();
+	}
+}

src/database/DatabaseManager.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <memory>
+
+#include "SqliteInterface.h"
+#include "Database.h"
+
+class DatabaseManager
+{
+
+	DatabasePtr mDatabase;
+	SqliteInterfacePtr mDatabaseInterface;
+
+public:
+
+	DatabaseManager();
+
+	~DatabaseManager();
+
+	static std::shared_ptr<DatabaseManager> Create();
+
+	void CreateDatabase(const std::string& path);
+
+	void OnShutDown();
+};
+
+using DatabaseManagerPtr = std::shared_ptr<DatabaseManager>;

src/database/database_interfaces/SqliteInterface.cpp

@@ -0,0 +1,56 @@
+#include "SqliteInterface.h"
+
+#include <iostream>
+
+SqliteInterface::SqliteInterface()
+	: mSqliteDb(nullptr)
+{
+
+}
+
+SqliteInterface::~SqliteInterface()
+{
+
+}
+
+std::shared_ptr<SqliteInterface> SqliteInterface::Create()
+{
+	return std::make_shared<SqliteInterface>();
+}
+
+void SqliteInterface::Open(DatabasePtr db)
+{
+	int rc = sqlite3_open(db->GetPath().c_str(), &mSqliteDb);
+	if( rc )
+	{
+		std::cout << "Can't open database: %s\n" << sqlite3_errmsg(mSqliteDb) << std::endl;
+		sqlite3_close(mSqliteDb);
+	}
+}
+
+static int callback(void *NotUsed, int argc, char **argv, char **azColName)
+{
+	for(int i=0; i<argc; i++)
+	{
+		//std::cout << "%s = %s\n" << azColName[i] << argv[i] ? argv[i] : "NULL" << std::endl;
+
+		std::cout <<  "NULL" << std::endl;
+	}
+	return 0;
+}
+
+void SqliteInterface::Run(const std::string& statement)
+{
+	char *zErrMsg = 0;
+	int rc = sqlite3_exec(mSqliteDb, statement.c_str(), callback, 0, &zErrMsg);
+	if( rc!=SQLITE_OK )
+	{
+		std::cout << "SQL error: %s\n" << zErrMsg << std::endl;
+		sqlite3_free(zErrMsg);
+	}
+}
+
+void SqliteInterface::Close()
+{
+	sqlite3_close(mSqliteDb);
+}

src/database/database_interfaces/SqliteInterface.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <memory>
+#include <sqlite3.h>
+
+#include "Database.h"
+
+class SqliteInterface
+{
+	sqlite3* mSqliteDb;
+
+public:
+
+	SqliteInterface();
+
+	~SqliteInterface();
+
+	static std::shared_ptr<SqliteInterface> Create();
+
+	void Open(DatabasePtr db);
+
+	void Close();
+
+	void Run(const std::string& statement);
+};
+
+using SqliteInterfacePtr = std::shared_ptr<SqliteInterface>;