SQLite Added with Modern C++.

MiniEngine.cpp

@@ -644,6 +644,8 @@ namespace MiniEngine
         case FlipMode::Vertical:
             flip=SDL_FLIP_VERTICAL;
             break;
+        default:
+            flip=SDL_FLIP_NONE;
         }
 
         return SDL_RenderCopyEx(_get(),t._get(),pR1,pR2,angle,pPoint,flip);
@@ -1255,14 +1257,28 @@ namespace MiniEngine
 		SDL_StopTextInput();
 	}
 
+	/// Global Executor For class Timer
+	Uint32 _global_timer_executor(Uint32 interval,void* param)
+	{
+	    printf("DEBUG: Global Timer Executor.\n");
+        auto p=reinterpret_cast<std::function<Uint32(Uint32 interval)>*>(param);
+        return (*p)(interval);
+	}
+
     Timer::Timer()
     {
         _enabled=false;
         _detached=false;
+        _delete_on_disable=false;
         id=-1;
     }
 
     Timer::Timer(SDL_TimerCallback callback,Uint32 interval,void* param) : Timer()
+    {
+        _real_timer_call(callback,interval,param);
+    }
+
+    void Timer::_real_timer_call(SDL_TimerCallback callback,Uint32 interval,void* param)
     {
         _callback=callback;
         _interval=interval;
@@ -1291,6 +1307,15 @@ namespace MiniEngine
             SDL_RemoveTimer(id);
             _enabled=false;
             id=-1;
+            _callback=nullptr;
+
+            if(_delete_on_disable)
+            {
+                _delete_delegator(reinterpret_cast<std::function<Uint32(Uint32 interval)>*>(_param));
+                _delete_on_disable=false;
+            }
+
+            _param=nullptr;
             return 0;
         }
         else
@@ -1312,6 +1337,12 @@ namespace MiniEngine
         }
     }
 
+    //static
+    void Timer::_delete_delegator(std::function<Uint32(Uint32)>* param)
+    {
+        delete param;
+    }
+
 	AudioPlayer::AudioPlayer()
 	{
 		if (!_sysAudioCounter)

MiniEngine.h

@@ -426,24 +426,43 @@ namespace MiniEngine
 		};
 	};
 
+	Uint32 _global_timer_executor(Uint32 interval,void* param);
+
 	class Timer
 	{
     public:
         Timer();
         /// Uint32 func(Uint32,void*) ...
+        template<typename Callable,typename... Args>
+        Timer(Callable&& callable,Uint32 interval,Args&&... args) : Timer()
+        {
+            auto realCall=[&](Uint32 interval)->Uint32{return callable(interval,args...);};
+            auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
+            _real_timer_call(_global_timer_executor,interval,pfunc);
+        }
+
+        /// Restore For Capability
         Timer(SDL_TimerCallback callback,Uint32 interval,void* param);
+
         int enable();
         int disable();
         bool isenable();
         void detach();
         ~Timer();
+
+        static void _delete_delegator(std::function<Uint32(Uint32)>* Delegator);
     private:
+
+        void _real_timer_call(SDL_TimerCallback callback,Uint32 interval,void* param);
+
         SDL_TimerCallback _callback;
         Uint32 _interval;
         void* _param;
         SDL_TimerID id;
         bool _enabled;
         bool _detached;
+        /// Reserved Variable For Template variable Parameter
+        bool _delete_on_disable;
 	};
 
 	class AudioPlayer

MiniEngine_SQLite.cpp

@@ -0,0 +1,106 @@
+#include "MiniEngine_SQLite.h"
+#include <cstring>
+#include <cstdio>
+
+namespace MiniEngine
+{
+
+namespace SQL
+{
+
+// private
+void SQLStatement::_set(sqlite3_stmt* p)
+{
+    _st.reset(p,sqlite3_finalize);
+}
+
+// private
+sqlite3_stmt* SQLStatement::_get() const
+{
+    return _st.get();
+}
+
+void SQLStatement::_setStmt(sqlite3_stmt* p)
+{
+    _set(p);
+}
+
+sqlite3_stmt* SQLStatement::_getStmt() const
+{
+    return _get();
+}
+
+bool SQLStatement::isReady() const
+{
+    return _get()!=nullptr;
+}
+
+
+int _global_sqldb_executor(void* ExParam,int colNum,char** colVal,char** colName)
+{
+    auto p=reinterpret_cast<std::function<int(int,char**,char**)>*>(ExParam);
+    return (*p)(colNum,colVal,colName);
+}
+
+
+void SQLDB::_set(sqlite3* p)
+{
+    _db.reset(p,sqlite3_close);
+}
+
+sqlite3* SQLDB::_get()
+{
+    return _db.get();
+}
+
+int SQLDB::open(const std::string& filename)
+{
+    sqlite3* _temp=nullptr;
+    int ret=sqlite3_open(filename.c_str(),&_temp);
+    _set(_temp);
+    return ret;
+}
+
+SQLStatement SQLDB::prepare(const std::string& SQLCommand)
+{
+    SQLStatement stmt;
+    sqlite3_stmt* pstmt=nullptr;
+    int ret=sqlite3_prepare(_get(),SQLCommand.c_str(),SQLCommand.size(),&pstmt,NULL);
+    if(ret<0) return stmt;
+    stmt._setStmt(pstmt);
+    return stmt;
+}
+
+int SQLDB::step(const SQLStatement& Statement)
+{
+    return sqlite3_step(Statement._getStmt());
+}
+
+int SQLDB::exec(const std::string& SQLCommand)
+{
+    return _exec_real(SQLCommand,nullptr,nullptr);
+}
+
+int SQLDB::exec(const std::string& SQLCommand,SQLCallback callback,void* param)
+{
+    return _exec_real(SQLCommand,callback,param);
+}
+
+int SQLDB::_exec_real(const std::string& SQLCommand,SQLCallback callback,void* param)
+{
+    return sqlite3_exec(_get(),SQLCommand.c_str(),callback,param,&_errmsg);
+}
+
+const char* SQLDB::getErrorMsg()
+{
+    return _errmsg;
+}
+
+void SQLDB::clearError()
+{
+    _errmsg=nullptr;
+}
+
+}/// End of namespace MiniEngine::SQL
+
+}/// End of namespace MiniEngine

MiniEngine_SQLite.h

@@ -0,0 +1,70 @@
+#pragma once
+#include "sqlite/sqlite3.h"
+#include <string>
+#include <memory>
+
+namespace MiniEngine
+{
+
+namespace SQL
+{
+
+class SQLStatement
+{
+public:
+    bool isReady() const;
+    SQLStatement()=default;
+    ~SQLStatement()=default;
+
+    void _setStmt(sqlite3_stmt*);
+    sqlite3_stmt* _getStmt() const;
+private:
+    sqlite3_stmt* _get() const;
+    void _set(sqlite3_stmt*);
+    std::shared_ptr<sqlite3_stmt> _st;
+};
+
+
+using SQLCallback = int (*)(void* ExParam,int colNum,char** colVal,char** colName);
+
+/// Global Executor
+int _global_sqldb_executor(void* ExParam,int colNum,char** colVal,char** colName);
+
+class SQLDB
+{
+public:
+    SQLDB()=default;
+    ~SQLDB()=default;
+
+    bool isOpened();
+    int open(const std::string& filename);
+    SQLStatement prepare(const std::string& SQLCommand);
+    int step(const SQLStatement& Statement);
+
+    template<typename Callable,typename... Args>
+    int exec(const std::string& SQLCommand,Callable&& callable,Args&&... args)
+    {
+        auto realCall=[&](int colNum,char** colVal,char** colName)->int{return callable(colNum,colVal,colName,args...);};
+        std::function<int(int,char**,char**)> func=realCall;
+        return _exec_real(SQLCommand,_global_sqldb_executor,&func);
+    }
+
+    int exec(const std::string& SQLCommand);
+
+    /// Reserved For Capability
+    int exec(const std::string& SQLCommand,SQLCallback callback,void* param);
+
+    const char* getErrorMsg();
+    void clearError();
+private:
+    int _exec_real(const std::string& SQLCommand,SQLCallback callback,void* param);
+
+    sqlite3* _get();
+    void _set(sqlite3*);
+    std::shared_ptr<sqlite3> _db;
+    char* _errmsg;
+};
+
+}/// End of namespace MiniEngine::SQL
+
+}/// End of namespace MiniEngine