Fix RowIterator and Add bidirectional ColumnIterator

Author: Kacperos155

include/SQLiteCpp/Column.h

@@ -55,8 +55,8 @@ class Column
         mStatementPtr(aStatementPtr),
         mIndex(aIndex), mRowIndex(mStatementPtr->mCurrentStep) {}
 
-    Column(const Column&) = delete;
-    Column& operator=(const Column&) = delete;
+    Column(const Column&) noexcept = default;
+    Column& operator=(const Column&) noexcept = default;
 
     Column(Column&& aColumn) noexcept = default;
     Column& operator=(Column&& aColumn) noexcept = default;

include/SQLiteCpp/Row.h

@@ -35,9 +35,73 @@ class Row
         return mID;
     }
 
+    /**
+    * @brief RandomAccessIterator for row columns.
+    */
+    class ColumnIterator
+    {
+    public:
+        //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) {}
+
+        reference operator*() const noexcept
+        {
+            return mColumn;
+        }
+        pointer operator->() const noexcept
+        {
+            return &mColumn;
+        }
+
+        ColumnIterator& operator++() noexcept
+        {
+            mColumn = Column(mpStatement, ++mID);
+            return *this;
+        }
+        ColumnIterator operator++(int) noexcept
+        {
+            ColumnIterator copy{ *this };
+            mColumn = Column(mpStatement, ++mID);
+            return copy;
+        }
+        ColumnIterator& operator--() noexcept
+        {
+            mColumn = Column(mpStatement, --mID);
+            return *this;
+        }
+        ColumnIterator operator--(int) noexcept
+        {
+            ColumnIterator copy{ *this };
+            mColumn = Column(mpStatement, --mID);
+            return copy;
+        }
+
+        bool operator==(const ColumnIterator& aIt) const noexcept;
+        bool operator!=(const ColumnIterator& aIt) const noexcept
+        {
+            return !(*this == aIt);
+        }
+
+    private:
+        TStatementPtr   mpStatement{};  //!< Shared pointer to prepared Statement Object
+        std::size_t     mRowID{};       //!< Current row number
+        uint16_t        mID{};          //!< Current column number
+
+        /// Internal column object storage
+        Column mColumn{ mpStatement, mID };
+    };
+
 private:
     TStatementWeakPtr mpStatement;
-    std::size_t mID;
+    std::size_t       mID;
 };
 
 }  // namespace SQLite

include/SQLiteCpp/StatementExecutor.h

@@ -173,9 +173,8 @@ class StatementExecutor
         using pointer = const Row*;
         using difference_type = std::ptrdiff_t;
 
-        RowIterator() = default;
-        RowIterator(TStatementWeakPtr apStatement, uint16_t aID) :
-            mpStatement(apStatement), mID(aID), mRow(apStatement, aID) {}
+        explicit RowIterator(TStatementWeakPtr apStatement = TStatementWeakPtr{}) :
+            mpStatement(apStatement) {}
 
         reference operator*() const noexcept
         {
@@ -188,16 +187,13 @@ class StatementExecutor
 
         RowIterator& operator++() noexcept
         {
-            mRow = Row(mpStatement, ++mID);
             advance();
             return *this;
         }
-        /// Prefer to use prefix increment (++it)
-        RowIterator operator++(int) noexcept
+        RowIterator& operator++(int) noexcept
         {
-            RowIterator copy{ *this };
             advance();
-            return copy;
+            return *this;
         }
 
         bool operator==(const RowIterator& aIt) const noexcept;
@@ -210,8 +206,8 @@ class StatementExecutor
         /// Executing next statement step
         void advance() noexcept;
 
-        TStatementWeakPtr   mpStatement{};  //!< Weak pointer to prepared Statement Object
-        uint16_t            mID{};          //!< Current row number
+        TStatementWeakPtr mpStatement{};  //!< Weak pointer to prepared Statement Object
+        std::size_t             mID{};          //!< Current row number
 
         /// Internal row object storage
         Row mRow{ mpStatement, mID };

src/Row.cpp

@@ -19,5 +19,22 @@ namespace SQLite
 {
 
 
+    bool Row::ColumnIterator::operator==(const ColumnIterator& aIt) const noexcept
+    {
+        const auto& left = mpStatement;
+        const auto& right = aIt.mpStatement;
+
+        if (mID != aIt.mID)
+            return false;
+
+        if (!left && !right)
+            return true;
+
+        if (left != right)
+            return false;
+
+        return mRowID == aIt.mRowID;
+    }
+
 
 }  // namespace SQLite

src/StatementExecutor.cpp

@@ -9,6 +9,7 @@
  * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
  * or copy at http://opensource.org/licenses/MIT)
  */
+#include <iterator>
 #include <SQLiteCpp/StatementExecutor.h>
 
 #include <SQLiteCpp/Exception.h>
@@ -148,7 +149,7 @@ namespace SQLite
     {
         reset();
         tryExecuteStep();
-        return StatementExecutor::RowIterator(mpStatement, 0);
+        return StatementExecutor::RowIterator(mpStatement);
     }
 
     StatementExecutor::RowIterator StatementExecutor::end() noexcept
@@ -158,6 +159,8 @@ namespace SQLite
 
     void StatementExecutor::RowIterator::advance() noexcept
     {
+        mRow = Row(mpStatement, ++mID);
+
         if (mpStatement.expired())
             return;
 
@@ -173,8 +176,8 @@ namespace SQLite
 
     bool StatementExecutor::RowIterator::operator==(const RowIterator& aIt) const noexcept
     {
-        auto left = mpStatement.lock();
-        auto right = aIt.mpStatement.lock();
+        const auto left = mpStatement.lock();
+        const auto right = aIt.mpStatement.lock();
 
         if (!left && !right)
             return true;