Implement working Row class.

Move more statement info to StatementPtr.
Replace int&uint16_t with int_fast16_t.

Author: Kacperos155

include/SQLiteCpp/Column.h

@@ -51,7 +51,7 @@ class Column
      * @param[in] aStmtPtr  Shared pointer to the prepared SQLite Statement Object.
      * @param[in] aIndex    Index of the column in the row of result, starting at 0
      */
-    explicit Column(const TStatementPtr& aStatementPtr, uint16_t aIndex) noexcept :
+    explicit Column(const TStatementPtr& aStatementPtr, int_fast16_t aIndex) noexcept :
         mStatementPtr(aStatementPtr),
         mIndex(aIndex), mRowIndex(mStatementPtr->mCurrentStep) {}
 
@@ -61,6 +61,14 @@ class Column
     Column(Column&& aColumn) noexcept = default;
     Column& operator=(Column&& aColumn) noexcept = default;
 
+    /**
+    * @return Column index in statement return table.
+    */
+    int_fast16_t getIndex() const noexcept
+    {
+        return mIndex;
+    }
+
     /**
      * @brief Return a pointer to the named assigned to this result column (potentially aliased)
      *
@@ -241,7 +249,7 @@ class Column
     sqlite3_stmt* getStatement() const;
 
     TStatementPtr   mStatementPtr;  ///< Shared Pointer to the prepared SQLite Statement Object
-    uint16_t        mIndex;         ///< Index of the column in the row of result, starting at 0
+    int_fast16_t    mIndex;         ///< Index of the column in the row of result, starting at 0
     std::size_t     mRowIndex;      ///< Index of the statement row, starting at 0
 };
 

include/SQLiteCpp/Row.h

@@ -11,9 +11,11 @@
  */
 #pragma once
 
+#include <SQLiteCpp/Exception.h>
 #include <SQLiteCpp/StatementPtr.h>
 #include <SQLiteCpp/Column.h>
 
+#include <iterator>
 #include <memory>
 #include <string>
 
@@ -22,35 +24,67 @@ namespace SQLite
 {
 
 /**
-* @brief CLASS IS WIP!
+* @brief Small class returned by StatementExecutor::RowIterator.
+* 
+* Use with for-range to iterate on statement columns.
 */
 class Row
 {
 public:
-    Row(TStatementWeakPtr apStatement, std::size_t aID) :
-        mpStatement(apStatement), mID(aID) {}
+    Row(TStatementWeakPtr apStatement, std::size_t aID);
 
-    std::size_t getRowNumber() const
+    /**
+    * @return Row ID/steps executed since statement start (starting at 0).
+    */
+    std::size_t getRowNumber() const noexcept
     {
         return mID;
     }
 
+    /**
+    * @return Column with given index
+    *
+    * @throws SQLite::Exception when index is out of bounds
+    */
+    Column operator[](int_fast16_t aIndex) const;
+    /**
+    * @return Column with given name
+    *
+    * @throws SQLite::Exception when there is no column with given name
+    */
+    Column operator[](const char* aName) const;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * @brief Return the index of the specified (potentially aliased) column name
+     *
+     * @param[in] apName Aliased name of the column, that is, the named specified in the query (not the original name)
+     *
+     * @throws SQLite::Exception if the specified name is not known.
+     */
+    int_fast16_t getColumnIndex(const char* apName) const;
+
+    ////////////////////////////////////////////////////////////////////////////
+
     /**
     * @brief RandomAccessIterator for row columns.
+    * 
+    * Use by using for-range on Row or by calling Row::begin().
     */
     class ColumnIterator
     {
     public:
-        //TODO: using iterator_category = std::random_access_iterator_tag;
+        // TODO: using iterator_category = std::random_access_iterator_tag;
         using iterator_category = std::bidirectional_iterator_tag;
         using value_type = Column;
         using reference = const Column&;
         using pointer = const Column*;
         using difference_type = std::ptrdiff_t;
 
         ColumnIterator() = default;
-        ColumnIterator(TStatementPtr apStatement, uint16_t aID) :
-            mpStatement(apStatement), mID(aID), mColumn(apStatement, aID) {}
+        ColumnIterator(TStatementPtr apStatement, int_fast16_t aID) :
+            mpStatement(apStatement), mRowID(apStatement->mCurrentStep), mID(aID), mColumn(apStatement, aID) {}
 
         reference operator*() const noexcept
         {
@@ -91,17 +125,41 @@ class Row
         }
 
     private:
-        TStatementPtr   mpStatement{};  //!< Shared pointer to prepared Statement Object
-        std::size_t     mRowID{};       //!< Current row number
-        uint16_t        mID{};          //!< Current column number
+        TStatementPtr   mpStatement;  //!< Shared pointer to prepared Statement Object
+        std::size_t     mRowID;       //!< Current row number
+        int_fast16_t    mID;          //!< Current column number
 
         /// Internal column object storage
         Column mColumn{ mpStatement, mID };
     };
 
+    /**
+    * @return RowIterator to first column of this prepared statement.
+    */
+    ColumnIterator begin() const;
+
+    /**
+    * @return RowIterator to after the last column of this prepared statement.
+    */
+    ColumnIterator end() const;
+
 private:
-    TStatementWeakPtr mpStatement;
-    std::size_t       mID;
+    /**
+    * @brief Checks if weak_ptr contains existing SQLite Statement Object.
+    * 
+    * @throws SQLite::Exception when weak_ptr is expired.
+    */
+    void checkStatement() const
+    {
+        if (mpStatement.expired())
+        {
+            throw SQLite::Exception("Row is used after destruction of SQLite Statement Object");
+        }
+    }
+
+    TStatementWeakPtr   mpStatement;    //!< Weak Pointer to the prepared SQLite Statement Object
+    std::size_t         mID;            //!< Index of the statement row, starting at 0
+    int_fast16_t        mColumnCount{}; //!< Number of columns in row
 };
 
 }  // namespace SQLite

include/SQLiteCpp/Statement.h

@@ -93,70 +93,70 @@ class Statement : public StatementExecutor
     // => if you know what you are doing, use bindNoCopy() instead of bind()
 
     SQLITECPP_PURE_FUNC
-    int getIndex(const char * const apName) const;
+    int getIndex(const char* const apName) const;
 
     /**
      * @brief Bind an int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const int aIndex, const int32_t       aValue);
+    void bind(const int_fast16_t aIndex, const int32_t      aValue);
     /**
      * @brief Bind a 32bits unsigned int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const int aIndex, const uint32_t      aValue);
+    void bind(const int_fast16_t aIndex, const uint32_t     aValue);
     /**
      * @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 int64_t       aValue);
+    void bind(const int_fast16_t aIndex, const int64_t      aValue);
     /**
      * @brief Bind a double (64bits float) value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const int aIndex, const double        aValue);
+    void bind(const int_fast16_t aIndex, const double       aValue);
     /**
      * @brief Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      *
      * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
      */
-    void bind(const int aIndex, const std::string&  aValue);
+    void bind(const int_fast16_t aIndex, const std::string& aValue);
     /**
      * @brief Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      *
      * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
      */
-    void bind(const int aIndex, const char*         apValue);
+    void bind(const int_fast16_t aIndex, const char*        apValue);
     /**
      * @brief Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      *
      * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
      */
-    void bind(const int aIndex, const void*         apValue, const int aSize);
+    void bind(const int_fast16_t aIndex, const void*        apValue, const int aSize);
     /**
      * @brief Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1).
      *
      * The string can contain null characters as it is binded using its size.
      *
      * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement.
      */
-    void bindNoCopy(const int aIndex, const std::string&    aValue);
+    void bindNoCopy(const int_fast16_t aIndex, const std::string&   aValue);
     /**
      * @brief Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      *
      * Main usage is with null-terminated literal text (aka in code static strings)
      *
      * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement.
      */
-    void bindNoCopy(const int aIndex, const char*           apValue);
+    void bindNoCopy(const int_fast16_t aIndex, const char*          apValue);
     /**
      * @brief Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      *
      * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement.
      */
-    void bindNoCopy(const int aIndex, const void*           apValue, const int aSize);
+    void bindNoCopy(const int_fast16_t aIndex, const void*          apValue, const int aSize);
     /**
      * @brief Bind a NULL value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      *
      * @see clearBindings() to set all bound parameters to NULL.
      */
-    void bind(const int aIndex);
+    void bind(const int_fast16_t aIndex);
 
     /**
      * @brief Bind an int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
@@ -258,28 +258,28 @@ class Statement : public StatementExecutor
     /**
      * @brief Bind an int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const std::string& aName, const int32_t         aValue)
+    void bind(const std::string& aName, const int32_t       aValue)
     {
         bind(aName.c_str(), aValue);
     }
     /**
      * @brief Bind a 32bits unsigned int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const std::string& aName, const uint32_t        aValue)
+    void bind(const std::string& aName, const uint32_t      aValue)
     {
         bind(aName.c_str(), aValue);
     }
     /**
      * @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 std::string& aName, const int64_t         aValue)
+    void bind(const std::string& aName, const int64_t       aValue)
     {
         bind(aName.c_str(), aValue);
     }
     /**
      * @brief Bind a double (64bits float) value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (aIndex >= 1)
      */
-    void bind(const std::string& aName, const double          aValue)
+    void bind(const std::string& aName, const double        aValue)
     {
         bind(aName.c_str(), aValue);
     }
@@ -288,7 +288,7 @@ class Statement : public StatementExecutor
      *
      * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
      */
-    void bind(const std::string& aName, const std::string&    aValue)
+    void bind(const std::string& aName, const std::string&  aValue)
     {
         bind(aName.c_str(), aValue);
     }
@@ -297,7 +297,7 @@ class Statement : public StatementExecutor
      *
      * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
      */
-    void bind(const std::string& aName, const char*           apValue)
+    void bind(const std::string& aName, const char*         apValue)
     {
         bind(aName.c_str(), apValue);
     }
@@ -306,7 +306,7 @@ class Statement : public StatementExecutor
      *
      * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
      */
-    void bind(const std::string& aName, const void*           apValue, const int aSize)
+    void bind(const std::string& aName, const void*         apValue, const int aSize)
     {
         bind(aName.c_str(), apValue, aSize);
     }
@@ -378,7 +378,7 @@ class Statement : public StatementExecutor
      *          Thus, you should instead extract immediately its data (getInt(), getText()...)
      *          and use or copy this data for any later usage.
      */
-    Column  getColumn(const int aIndex);
+    Column  getColumn(const int_fast16_t aIndex);
 
     /**
      * @brief Return a copy of the column data specified by its column name (less efficient than using an index)
@@ -431,12 +431,12 @@ class Statement : public StatementExecutor
      *
      * @note Requires std=C++14
      */
-    template<typename T, int N>
+    template<typename T, int_fast16_t N>
     T getColumns()
     {
         checkRow();
         checkIndex(N - 1);
-        return getColumns<T>(std::make_integer_sequence<int, N>{});
+        return getColumns<T>(std::make_integer_sequence<int_fast16_t, N>{});
     }
 
 private:
@@ -449,7 +449,7 @@ class Statement : public StatementExecutor
     * @return Column object for each column in statement
     */
     template<typename T, const int... Is>
-    T getColumns(const std::integer_sequence<int, Is...>)
+    T getColumns(const std::integer_sequence<int_fast16_t, Is...>)
     {
         return T{ Column(getStatementPtr(), Is)... };
     }
@@ -466,7 +466,7 @@ class Statement : public StatementExecutor
      *
      *  Throw an exception if the specified index is out of the [0, getColumnCount()) range.
      */
-    bool    isColumnNull(const int aIndex) const;
+    bool    isColumnNull(const int_fast16_t aIndex) const;
 
     /**
      * @brief Test if the column value is NULL
@@ -488,7 +488,7 @@ class Statement : public StatementExecutor
      *
      *  Throw an exception if the specified index is out of the [0, getColumnCount()) range.
      */
-    const char* getColumnName(const int aIndex) const;
+    const char* getColumnName(const int_fast16_t aIndex) const;
 
 #ifdef SQLITE_ENABLE_COLUMN_METADATA
     /**
@@ -500,7 +500,7 @@ class Statement : public StatementExecutor
      *
      *  Throw an exception if the specified index is out of the [0, getColumnCount()) range.
      */
-    const char* getColumnOriginName(const int aIndex) const;
+    const char* getColumnOriginName(const int_fast16_t aIndex) const;
 #endif
 
     /**
@@ -528,7 +528,7 @@ class Statement : public StatementExecutor
      *  - the statement is not a SELECT query
      *  - the column at aIndex is not a table column but an expression or subquery
      */
-    const char* getColumnDeclaredType(const int aIndex) const;
+    const char* getColumnDeclaredType(const int_fast16_t aIndex) const;
 
     ////////////////////////////////////////////////////////////////////////////