Add a RAII-class for sqlite managed memory

Added a detail namnespace containing a new class for managing memory allocated
with the function sqllite3_alloc().

The new class is:
 - Default constructible (creates a null buffer)
 - Copy constructible and copy assignable (copies the memory buffer size and
   contents into a new memory buffer)
 - Move constructible and move assignable.

Author: fr00b0

CppSQLite3.cpp

@@ -7,6 +7,7 @@
 
 #include "CppSQLite3.h"
 #include <cstdlib>
+#include <utility>
 
 
 // Named constant for passing to CppSQLite3Exception when passing it a string
@@ -22,6 +23,94 @@ int sqlite3_decode_binary(const unsigned char *in, unsigned char *out);
 
 ////////////////////////////////////////////////////////////////////////////////
 
+namespace detail
+{
+
+SQLite3Memory::SQLite3Memory() :
+    mnBufferLen(0),
+    mpBuf(nullptr)
+{
+}
+
+SQLite3Memory::SQLite3Memory(int nBufferLen) :
+    mnBufferLen(nBufferLen),
+    mpBuf(sqlite3_malloc(nBufferLen))
+{
+    if (!mpBuf && mnBufferLen>0)
+    {
+        throw CppSQLite3Exception(CPPSQLITE_ERROR,
+                                "Cannot allocate memory",
+                                DONT_DELETE_MSG);
+    }
+}
+
+SQLite3Memory::SQLite3Memory(const char* szFormat, va_list list) :
+    mnBufferLen(0),
+    mpBuf(sqlite3_vmprintf(szFormat, list))
+{
+    if (!mpBuf)
+    {
+        throw CppSQLite3Exception(CPPSQLITE_ERROR,
+                                "Cannot allocate memory",
+                                DONT_DELETE_MSG);
+    }
+    mnBufferLen = std::strlen(static_cast<char const*>(mpBuf))+1;
+}
+
+SQLite3Memory::~SQLite3Memory()
+{
+    clear();
+}
+
+SQLite3Memory::SQLite3Memory(SQLite3Memory const& other) :
+    mnBufferLen(other.mnBufferLen),
+    mpBuf(sqlite3_malloc(other.mnBufferLen))
+{
+    if (!mpBuf && mnBufferLen>0)
+    {
+        throw CppSQLite3Exception(CPPSQLITE_ERROR,
+                                "Cannot allocate memory",
+                                DONT_DELETE_MSG);
+    }
+    std::memcpy(mpBuf, other.mpBuf, mnBufferLen);
+}
+
+SQLite3Memory& SQLite3Memory::operator=(SQLite3Memory const& lhs)
+{
+    SQLite3Memory tmp(lhs);
+    swap(tmp);
+    return *this;
+}
+
+SQLite3Memory::SQLite3Memory(SQLite3Memory&& other) :
+    mnBufferLen(other.mnBufferLen),
+    mpBuf(other.mpBuf)
+{
+    other.mnBufferLen = 0;
+    other.mpBuf = nullptr;
+}
+
+SQLite3Memory& SQLite3Memory::operator=(SQLite3Memory&& lhs)
+{
+    swap(lhs);
+    return *this;
+}
+
+void SQLite3Memory::swap(SQLite3Memory& other)
+{
+    std::swap(mnBufferLen, other.mnBufferLen);
+    std::swap(mpBuf, other.mpBuf);
+}
+
+void SQLite3Memory::clear()
+{
+    sqlite3_free(mpBuf);
+    mpBuf = nullptr;
+    mnBufferLen = 0;
+}
+
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 CppSQLite3Exception::CppSQLite3Exception(const int nErrCode,
@@ -40,7 +129,7 @@ CppSQLite3Exception::CppSQLite3Exception(const int nErrCode,
     }
 }
 
-                                    
+
 CppSQLite3Exception::CppSQLite3Exception(const CppSQLite3Exception&  e) :
                                     mnErrCode(e.mnErrCode)
 {
@@ -995,7 +1084,7 @@ void CppSQLite3Statement::bind(int nParam, const long long nValue)
 {
     checkVM();
     int nRes = sqlite3_bind_int64(mpVM, nParam, nValue);
-    
+
     if (nRes != SQLITE_OK)
     {
         throw CppSQLite3Exception(nRes,
@@ -1033,7 +1122,7 @@ void CppSQLite3Statement::bind(int nParam, const unsigned char* blobValue, int n
     }
 }
 
-    
+
 void CppSQLite3Statement::bindNull(int nParam)
 {
     checkVM();
@@ -1303,7 +1392,7 @@ sqlite3_stmt* CppSQLite3DB::compile(const char* szSQL)
 
 ////////////////////////////////////////////////////////////////////////////////
 // SQLite encode.c reproduced here, containing implementation notes and source
-// for sqlite3_encode_binary() and sqlite3_decode_binary() 
+// for sqlite3_encode_binary() and sqlite3_decode_binary()
 ////////////////////////////////////////////////////////////////////////////////
 
 /*
@@ -1350,7 +1439,7 @@ sqlite3_stmt* CppSQLite3DB::compile(const char* szSQL)
 ** We would prefer to keep the size of the encoded string smaller than
 ** this.
 **
-** To minimize the encoding size, we first add a fixed offset value to each 
+** To minimize the encoding size, we first add a fixed offset value to each
 ** byte in the sequence.  The addition is modulo 256.  (That is to say, if
 ** the sum of the original character value and the offset exceeds 256, then
 ** the higher order bits are truncated.)  The offset is chosen to minimize
@@ -1359,7 +1448,7 @@ sqlite3_stmt* CppSQLite3DB::compile(const char* szSQL)
 ** characters, the offset might be 0x01.  Each of the 0x27 characters would
 ** then be converted into an 0x28 character which would not need to be
 ** escaped at all and so the 100 character input string would be converted
-** into just 100 characters of output.  Actually 101 characters of output - 
+** into just 100 characters of output.  Actually 101 characters of output -
 ** we have to record the offset used as the first byte in the sequence so
 ** that the string can be decoded.  Since the offset value is stored as
 ** part of the output string and the output string is not allowed to contain
@@ -1382,7 +1471,7 @@ sqlite3_stmt* CppSQLite3DB::compile(const char* szSQL)
 **
 ** Decoding is obvious:
 **
-**     (5)   Copy encoded characters except the first into the decode 
+**     (5)   Copy encoded characters except the first into the decode
 **           buffer.  Set the first encoded character aside for use as
 **           the offset in step 7 below.
 **
@@ -1408,7 +1497,7 @@ sqlite3_stmt* CppSQLite3DB::compile(const char* szSQL)
 
 /*
 ** Encode a binary buffer "in" of size n bytes so that it contains
-** no instances of characters '\'' or '\000'.  The output is 
+** no instances of characters '\'' or '\000'.  The output is
 ** null-terminated and can be used as a string value in an INSERT
 ** or UPDATE statement.  Use sqlite3_decode_binary() to convert the
 ** string back into its original binary.

CppSQLite3.h

@@ -14,6 +14,51 @@
 
 #define CPPSQLITE_ERROR 1000
 
+namespace detail
+{
+    /**
+     * RAII class for managing memory allocated by sqlite
+    */
+    class SQLite3Memory
+    {
+    public:
+
+        // Default constructor
+        SQLite3Memory();
+        // Constructor that allocates memory of a given size
+        SQLite3Memory(int nBufferLen);
+        // Constructor that formats a string with sqlite memory allocation
+        SQLite3Memory(const char* szFormat, va_list list);
+        // Destructor
+        ~SQLite3Memory();
+
+        // Copy constructor
+        SQLite3Memory(SQLite3Memory const& other);
+        // Copy assignment
+        SQLite3Memory& operator=(SQLite3Memory const& lhs);
+
+        // Move constructor
+        SQLite3Memory(SQLite3Memory&& other);
+        // Move assignment
+        SQLite3Memory& operator=(SQLite3Memory&& lhs);
+
+        // Swap operation
+        void swap(SQLite3Memory& other);
+
+        int getLength() const { return mnBufferLen; }
+
+        void* getBuffer() const { return mpBuf; }
+
+        void clear();
+
+    private:
+
+        int mnBufferLen;
+        void* mpBuf;
+    };
+}
+
+
 class CppSQLite3Exception
 {
 public: