Switch from sqlite3_int64 to int64_t

Author: SRombauts

.project

@@ -5,6 +5,11 @@
 	<projects>
 	</projects>
 	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
 			<triggers>clean,full,incremental,</triggers>
@@ -75,5 +80,6 @@
 		<nature>org.eclipse.cdt.core.ccnature</nature>
 		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
 		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+		<nature>org.python.pydev.pythonNature</nature>
 	</natures>
 </projectDescription>

cpplint.py

@@ -4499,7 +4499,7 @@ def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,
     template = required[required_header_unstripped][1]
     if required_header_unstripped.strip('<>"') not in include_state:
       error(filename, required[required_header_unstripped][0],
-            'build/include_what_you_use', 4,
+            'build/include_what_you_use', 2,
             'Add #include ' + required_header_unstripped + ' for ' + template)
 
 

include/SQLiteCpp/Column.h

@@ -16,6 +16,7 @@
 #include <SQLiteCpp/Exception.h>
 
 #include <string>
+#include <stdint.h>
 
 
 namespace SQLite
@@ -41,32 +42,32 @@ namespace SQLite
 class Column
 {
 public:
-    // Make clang happy by explicitly implementing the copy-constructor:
-    Column(const Column & aOther) :
-        mStmtPtr(aOther.mStmtPtr),
-        mIndex(aOther.mIndex)
-    {
-    }
-
     /**
      * @brief Encapsulation of a Column in a Row of the result.
      *
      * @param[in] aStmtPtr  Shared pointer to the prepared SQLite Statement Object.
      * @param[in] aIndex    Index of the column in the row of result
      */
     Column(Statement::Ptr& aStmtPtr, int aIndex)    noexcept; // nothrow
-    /// @brief Simple destructor
+    /// Simple destructor
     virtual ~Column()                               noexcept; // nothrow
 
     // default copy constructor and assignment operator are perfectly suited :
     // they copy the Statement::Ptr which in turn increments the reference counter.
 
+    /// Make clang happy by explicitly implementing the copy-constructor:
+    Column(const Column & aOther) :
+        mStmtPtr(aOther.mStmtPtr),
+        mIndex(aOther.mIndex)
+    {
+    }
+
     /**
      * @brief Return a pointer to the named assigned to this result column (potentially aliased)
      *
      * @see getOriginName() to get original column name (not aliased)
      */
-    const char*     getName() const noexcept; // nothrow
+    const char* getName() const noexcept; // nothrow
 
 #ifdef SQLITE_ENABLE_COLUMN_METADATA
     /**
@@ -76,36 +77,36 @@ class Column
      * - when building the SQLite library itself (which is the case for the Debian libsqlite3 binary for instance),
      * - and also when compiling this wrapper.
      */
-    const char*     getOriginName() const noexcept; // nothrow
+    const char* getOriginName() const noexcept; // nothrow
 #endif
 
-    /// @brief Return the integer value of the column.
-    int             getInt() const noexcept; // nothrow
-    /// @brief Return the 64bits integer value of the column.
-    sqlite3_int64   getInt64() const noexcept; // nothrow
-    /// @brief Return the double (64bits float) value of the column.
-    double          getDouble() const noexcept; // nothrow
+    /// Return the integer value of the column.
+    int         getInt() const noexcept; // nothrow
+    /// Return the 64bits integer value of the column.
+    int64_t     getInt64() const noexcept; // nothrow
+    /// Return the double (64bits float) value of the column.
+    double      getDouble() const noexcept; // nothrow
     /**
      * @brief Return a pointer to the text value (NULL terminated string) of the column.
      *
      * @warning The value pointed at is only valid while the statement is valid (ie. not finalized),
      *          thus you must copy it before using it beyond its scope (to a std::string for instance).
      */
-    const char*     getText(const char* apDefaultValue = "") const noexcept; // nothrow
+    const char* getText(const char* apDefaultValue = "") const noexcept; // nothrow
     /**
      * @brief Return a pointer to the binary blob value of the column.
      *
      * @warning The value pointed at is only valid while the statement is valid (ie. not finalized),
      *          thus you must copy it before using it beyond its scope (to a std::string for instance).
      */
-    const void*     getBlob() const noexcept; // nothrow
+    const void* getBlob() const noexcept; // nothrow
     /**
      * @brief Return a std::string for a TEXT or BLOB column.
      *
      * Note this correctly handles strings that contain null bytes.
      *
      */
-    std::string     getString() const noexcept; // nothrow
+    std::string getString() const noexcept; // nothrow
 
     /**
      * @brief Return the type of the value of the column
@@ -117,27 +118,27 @@ class Column
      */
     int getType() const noexcept; // nothrow
 
-    /// @brief Test if the column is an integer type value (meaningful only before any conversion)
+    /// Test if the column is an integer type value (meaningful only before any conversion)
     inline bool isInteger() const noexcept // nothrow
     {
         return (SQLITE_INTEGER == getType());
     }
-    /// @brief Test if the column is a floating point type value (meaningful only before any conversion)
+    /// Test if the column is a floating point type value (meaningful only before any conversion)
     inline bool isFloat() const noexcept // nothrow
     {
         return (SQLITE_FLOAT == getType());
     }
-    /// @brief Test if the column is a text type value (meaningful only before any conversion)
+    /// Test if the column is a text type value (meaningful only before any conversion)
     inline bool isText() const noexcept // nothrow
     {
         return (SQLITE_TEXT == getType());
     }
-    /// @brief Test if the column is a binary blob type value (meaningful only before any conversion)
+    /// Test if the column is a binary blob type value (meaningful only before any conversion)
     inline bool isBlob() const noexcept // nothrow
     {
         return (SQLITE_BLOB == getType());
     }
-    /// @brief Test if the column is NULL (meaningful only before any conversion)
+    /// Test if the column is NULL (meaningful only before any conversion)
     inline bool isNull() const noexcept // nothrow
     {
         return (SQLITE_NULL == getType());
@@ -154,28 +155,42 @@ class Column
      */
     int getBytes() const noexcept;
 
-    /// @brief Alias returning the number of bytes used by the text (or blob) value of the column
+    /// Alias returning the number of bytes used by the text (or blob) value of the column
     inline int size() const noexcept
     {
         return getBytes ();
     }
 
-    /// @brief Inline cast operator to int
+    /// Inline cast operator to int
     inline operator int() const
     {
         return getInt();
     }
-    /// @brief Inline cast operator to 32bits unsigned integer
-    inline operator uint32_t() const
+#ifndef __x86_64__
+    /// Inline cast operator to long as 32bits integer for 32bit systems
+    inline operator long() const
     {
-        return static_cast<uint32_t>(getInt64());
+        return getInt();
+    }
+#endif // __x86_64__
+#if defined(__GNUC__) && !defined(__APPLE__)
+    /// Inline cast operator to long long for GCC and Clang
+    inline operator long long() const
+    {
+        return getInt64();
     }
-    /// @brief Inline cast operator to 64bits integer
-    inline operator sqlite3_int64() const
+#endif // __GNUC__
+    /// Inline cast operator to 64bits integer
+    inline operator int64_t() const
     {
         return getInt64();
     }
-    /// @brief Inline cast operator to double
+    /// Inline cast operator to 32bits unsigned integer
+    inline operator uint32_t() const
+    {
+        return static_cast<uint32_t>(getInt64());
+    }
+    /// Inline cast operator to double
     inline operator double() const
     {
         return getDouble();
@@ -218,18 +233,7 @@ class Column
     }
 #endif
 
-    // NOTE : the following is required by GCC and Clang to cast a Column result in a long/int64_t
-    /// @brief Inline cast operator to long as 64bits integer
-    inline operator long() const
-    {
-#ifdef __x86_64__
-        return getInt64();
-#else
-        return getInt();
-#endif
-    }
-
-    /// @brief Return UTF-8 encoded English language explanation of the most recent error.
+    /// Return UTF-8 encoded English language explanation of the most recent error.
     inline const char* errmsg() const
     {
         return sqlite3_errmsg(mStmtPtr);

include/SQLiteCpp/Database.h

@@ -237,7 +237,7 @@ class Database
      *
      * @return Rowid of the most recent successful INSERT into the database, or 0 if there was none.
      */
-    inline sqlite3_int64 getLastInsertRowid() const noexcept // nothrow
+    inline int64_t getLastInsertRowid() const noexcept // nothrow
     {
         return sqlite3_last_insert_rowid(mpSQLite);
     }
@@ -252,25 +252,25 @@ class Database
         return sqlite3_total_changes(mpSQLite);
     }
 
-    /// @brief Return the filename used to open the database.
+    /// Return the filename used to open the database.
     inline const std::string& getFilename() const noexcept // nothrow
     {
         return mFilename;
     }
 
-    /// @brief Return the numeric result code for the most recent failed API call (if any).
+    /// Return the numeric result code for the most recent failed API call (if any).
     inline int getErrorCode() const noexcept // nothrow
     {
         return sqlite3_errcode(mpSQLite);
     }
 
-    /// @brief Return the extended numeric result code for the most recent failed API call (if any).
+    /// Return the extended numeric result code for the most recent failed API call (if any).
     inline int getExtendedErrorCode() const noexcept // nothrow
     {
         return sqlite3_extended_errcode(mpSQLite);
     }
 
-    /// @brief Return UTF-8 encoded English language explanation of the most recent failed API call (if any).
+    /// Return UTF-8 encoded English language explanation of the most recent failed API call (if any).
     inline const char* errmsg() const noexcept // nothrow
     {
         return sqlite3_errmsg(mpSQLite);

include/SQLiteCpp/Statement.h

@@ -68,14 +68,10 @@ class Statement
      */
     Statement(Database& aDatabase, const std::string& aQuery);
 
-    /**
-     * @brief Finalize and unregister the SQL query from the SQLite Database Connection.
-     */
+    /// Finalize and unregister the SQL query from the SQLite Database Connection.
     virtual ~Statement() noexcept; // nothrow
 
-    /**
-     * @brief Reset the statement to make it ready for a new execution.
-     */
+    /// Reset the statement to make it ready for a new execution.
     void reset();
 
     /**
@@ -110,7 +106,7 @@ class Statement
     /**
      * @brief Bind a 64bits int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const int aIndex, const sqlite3_int64 aValue);
+    void bind(const int aIndex, const int64_t       aValue);
     /**
      * @brief Bind a 32bits unsigned int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
@@ -169,7 +165,7 @@ class Statement
     /**
      * @brief Bind a 64bits int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const char* apName, const sqlite3_int64   aValue);
+    void bind(const char* apName, const int64_t         aValue);
     /**
      * @brief Bind a 32bits unsigned int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
@@ -232,7 +228,7 @@ class Statement
     /**
      * @brief Bind a 64bits int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    inline void bind(const std::string& aName, const sqlite3_int64  aValue)
+    inline void bind(const std::string& aName, const int64_t        aValue)
     {
         bind(aName.c_str(), aValue);
     }
@@ -314,7 +310,6 @@ class Statement
         bind(aName.c_str());
     }
 
-
     ////////////////////////////////////////////////////////////////////////////
 
     /**
@@ -449,32 +444,32 @@ class Statement
 
     ////////////////////////////////////////////////////////////////////////////
 
-    /// @brief Return the UTF-8 SQL Query.
+    /// Return the UTF-8 SQL Query.
     inline const std::string& getQuery() const
     {
         return mQuery;
     }
-    /// @brief Return the number of columns in the result set returned by the prepared statement
+    /// Return the number of columns in the result set returned by the prepared statement
     inline int getColumnCount() const
     {
         return mColumnCount;
     }
-    /// @brief true when a row has been fetched with executeStep()
+    /// true when a row has been fetched with executeStep()
     inline bool isOk() const
     {
         return mbOk;
     }
-    /// @brief true when the last executeStep() had no more row to fetch
+    /// true when the last executeStep() had no more row to fetch
     inline bool isDone() const
     {
         return mbDone;
     }
-    /// @brief Return the numeric result code for the most recent failed API call (if any).
+    /// Return the numeric result code for the most recent failed API call (if any).
     inline int getErrorCode() const noexcept // nothrow
     {
         return sqlite3_errcode(mStmtPtr);
     }
-    /// @brief Return the extended numeric result code for the most recent failed API call (if any).
+    /// Return the extended numeric result code for the most recent failed API call (if any).
     inline int getExtendedErrorCode() const noexcept // nothrow
     {
         return sqlite3_extended_errcode(mStmtPtr);
@@ -503,13 +498,13 @@ class Statement
         // Decrement the ref counter and finalize the sqlite3_stmt when it reaches 0
         ~Ptr() noexcept; // nothrow (no virtual destructor needed here)
 
-        /// @brief Inline cast operator returning the pointer to SQLite Database Connection Handle
+        /// Inline cast operator returning the pointer to SQLite Database Connection Handle
         inline operator sqlite3*() const
         {
             return mpSQLite;
         }
 
-        /// @brief Inline cast operator returning the pointer to SQLite Statement Object
+        /// Inline cast operator returning the pointer to SQLite Statement Object
         inline operator sqlite3_stmt*() const
         {
             return mpStmt;

src/Backup.cpp

@@ -15,8 +15,6 @@
 
 #include <sqlite3.h>
 
-#include <string>
-
 namespace SQLite
 {